[Linguaggi] Dubbi su pre e post incremento (decremento),lvalue ed rvalue

[Gremo]

Ciao a tutti. Devo sostenere Linguaggi 1, sul mio libro non riesco a trovare esempi e neppure su internet. Ho solo esercizi del prof. con i risultati, senza spiegazione. Spero mi possiate aiutare o indirizzare verso qualche buon testo. Si parla in generale di linguaggi C-like.

Qualcosa di semplice:

x = 3; z = 2;
x += z++;

dovrebbe essere equivalente a scrivere:

x = x + z;
z = z + 1;

Se c'è un array di mezzo, Cosa succede?

foo(a[i++]);
equivale a:
foo(a[i]);
i = i + 1;

cioè quando ritorna foo(), allora i viene incrementato. Quindi se accedo a i, ad esempio nel corpo di foo(), il valore è da considerarsi senza incremento?

Ultimo caso. Se ho una chiamata a funzione:

v = 3;
G(v-- + R(v))

dove R è un'altra funzione, come viene valutato ciò che è dentro G? Viene chiamato G(3 + R(2)), o G(3 + R(3)) e al ritorno della chiamata viene decrementato v?

chiedo veramente un aiuto, un tutorial, altrimenti potrei impazzire (già studiare il 5 agosto... ). E pensare che credevo di conoscere il linguaggi

Ciao

[british]

x = 3; z = 2;
x += z++;

dovrebbe essere equivalente a scrivere:

x = x + z;
z = z + 1;

mi sembra corretto

foo(a[i++]);
equivale a:
foo(a[i]);
i = i + 1;

mi sembra corretto

v = 3;
G(v-- + R(v))

questo è il più interessante. sono abbastanza sicuro che in C e C++ il comportamento del compilatore sia indefinito.

EDIT: guarda se questo ti può interessare:
http://www.embedded.com/story/OEG20020429S0037

ciao!

british

[Energy++]

cioè quando ritorna foo(), allora i viene incrementato. Quindi se accedo a i, ad esempio nel corpo di foo(), il valore è da considerarsi senza incremento?

prima di tutto nella funzione foo() non hai accesso alla i, ma solo al valore i-esimo dell'array che viene passato come argomento e poi:

se i = 10

foo(a[i++); equivale a foo(a[10]);

la i viene incrementata solo dopo aver effettuato la chiamata alla funzione.

[Gremo]

Originariamente inviato da british

[code]

v = 3;
G(v-- + R(v))

questo è il più interessante. sono abbastanza sicuro che in C e C++ il comportamento del compilatore sia indefinito.

british

Non è indefinito, è sugli esercizi del professore. Cmq leggendo velocemente l'articolo che mi hai linkato, mi è venuto in mente che è specificato, nell'esercizio, ordine di valutazione degli argomenti da sinistra a destra. Quindi quale sarebbe l'invocazione corretta?

[Gremo]

Originariamente inviato da Energy++

cioè quando ritorna foo(), allora i viene incrementato. Quindi se accedo a i, ad esempio nel corpo di foo(), il valore è da considerarsi senza incremento?

prima di tutto nella funzione foo() non hai accesso alla i, ma solo al valore i-esimo dell'array che viene passato come argomento e poi:

se i = 10

foo(a[i++); equivale a foo(a[10]);

la i viene incrementata solo dopo aver effettuato la chiamata alla funzione.

Se consideri questi blocchi (anche senza l'array):

{
i= 1;
void foo(by value int x) {
x = 4; // non serve a nulla
stampa(i);
}

foo(i++);
}

EDIT:
quindi i viene incrementata subito dopo la chiamata (quando ENTRO in foo()), o quando la chiamata ritorna?

[banryu79]

Originariamente inviato da Gremo

Se consideri questi blocchi (anche senza l'array):

{
i= 1;
void foo(by value int x) {
x = 4; // non serve a nulla
stampa(i);
}

foo(i++);
}

EDIT:
quindi i viene incrementata subito dopo la chiamata (quando ENTRO in foo()), o quando la chiamata ritorna?

Ma non puoi scrivere del codice che ti stampi a video il valore di 'i' subito prima della chiamata, all'inizio dell'esecuzione del corpo della funzione 'foo' e subito dopo che la funzione è tornata?
Lo mandi in esecuzione e ti togli il dubbio

Comunque, se non erro, la definizione degli operatori di pre e post incremento è ben definita:
++(expression)
L'operatore di pre-incremento aggiunge 1 a expression e restituisce il risultato.
expression++
L'operatore di post-incremento aggiunge 1 a expression e restituisce il valore iniziale di expression (il valore prima dell'addizione).

Percui nel tuo esempio che ho quotato la variabile 'i', inizializzata al valore 1, quando viene passata per copia del valore alla invocazione della funzione 'foo', la copia passata vale ancora 1 (in quanto è il valore di ritorno dell'operatore di post-incremento e di conseguenza il parametro formale 'x' dentro lo scope di 'foo' vale 1) mentre la variabile 'i' vale 2.

[Kralizek]

Originariamente inviato da british

v = 3;
G(v-- + R(v))

questo è il più interessante. sono abbastanza sicuro che in C e C++ il comportamento del compilatore sia indefinito.

Io propendo per

G(3 + R(2))

[astorcas]

Originariamente inviato da Kralizek

Io propendo per

G(3 + R(2))

quoto

[Rsk]

Originariamente inviato da Kralizek

Io propendo per

G(3 + R(2))

Io per G(3 + R(3)) . MINGW32

Edit:

Nel C l'ordine di valutazione degli operandi di un qualsiasi operatore non e' conosciuto a priori (ad eccezione degli operatori '&&', '||' '?:' e ','). Questo significa che data l'espressione a = f1() + f2(), non e' possibile sapere a priori se verra' valutata prima la funzione f1() e poi la funzione f2() o viceversa. Pertanto se la funzione f1() altera il valore di una variabile utilizzata dall'altra funzione f2() o viceversa, il risultato dipendera' dall'ordine di valutazione delle due funzioni. Non e' conosciuto a priori nemmeno l'ordine di valutazione degli argomenti passati ad una funzione, pertanto una chiamata a funzione del tipo: 'funz(a, ++a)' produce un risultato dipendente dall'implementazione del compilatore usato. Situazione analoga si puo' avere in una chiamata a funzione del tipo: 'funz (funz2(a) - funz2(b))' se il valore ritornato da funz2() puo' risultare diverso tra la prima e la seconda chiamata

http://www.wowarea.com/italiano/linux/linguaggioc06.htm

[yorkeiser]

Su Code::Blocks (quindi compilatore mingw):

G(3+R(3))

Sarei curioso di provarla sul cl microsoft, ma non ce l'ho installato qui.

[xblitz]

Io ho provato a fare il programma:

#include <iostream>

using namespace std;

void G(int arg)
{
    cout << "G: v-- + R(v): " << arg <<"\n";
}
int R(int arg)
{
    cout << "R: v= " << arg<<"\n";
    return arg;
}

int main()
{
    int v=3;
    G(v-- + R(v));
    cout << "v: " << v;
    cout << "\n";
    return 0;
}

E questo è l'output.. forse è un po arzigogolato ma spero si capisca lo stesso :

R: v= 3
G: v-- + R(v): 6
v: 2

EDIT: code::blocks su windows

[astorcas]

Originariamente inviato da yorkeiser

Su Code::Blocks (quindi compilatore mingw):

G(3+R(3))

Sarei curioso di provarla sul cl microsoft, ma non ce l'ho installato qui.

vs 2005, c#, G(3 + R(2))

[xblitz]

Originariamente inviato da yorkeiser

Sarei curioso di provarla sul cl microsoft, ma non ce l'ho installato qui.

a me su VS 2008, quindi visual C++, da lo stesso output del mio post precedente.

[banryu79]

Minchia, è partita l'investigazione di massa

[yorkeiser]

Originariamente inviato da astorcas

vs 2005, c#, G(3 + R(2))

Java 6 concorda.
Attendiamo cdimauro per il pitone

[astorcas]

Originariamente inviato da xblitz

a me su VS 2008, quindi visual C++, da lo stesso output del mio post precedente.

   public class Program
    {
        static void Main(string[] args)
        {
            int v = 3;
            G(v--, R(v));
            Console.Read();
        }

        static int R(int j)
        {
            Console.WriteLine("R: a = {0}", j);
            return j;
        }

        static int G(int a, int b)
        {
            Console.WriteLine("G: a = {0} b = {1}, a+b = {2}", a, b, a + b);
            return a + b;
        }

    }
}

Output:

R: a = 2
G: a = 3 b = 2, a+b = 5

[malocchio]

Ovvero, comportamento indefinito per C/C++ (dipende dal compilatore...)?

[xblitz]

Originariamente inviato da astorcas

[cut]

ma questo è C# o sbaglio?

[yorkeiser]

Originariamente inviato da malocchio

Ovvero, comportamento indefinito per C/C++ (dipende dal compilatore...)?

Propendo per il sì, bisognerebbe però provare con altri compilatori c (non c#)

EDIT: ho visto ora il post di xblitz, per ora in entrambi i casi (mingw e cl microsoft) viene valutata come g(3+r(3))

[astorcas]

Originariamente inviato da xblitz

ma questo è C# o sbaglio?

si si io infatti facevo la mia parte col c#, non dovevo?

EDIT: a me cmq sembra che tutti quelli che hanno fatto prove col c++ hanno avuto lo stesso risultato, ossia diverso da tutti gli altri linguaggi