Newsgroup: it.comp.lang.c++
Titolo: "A& f()" vs "A f()"

Salve... rieccomi!
Non perdete tempo con questo messaggio, se non ne avete da perdere... si
tratta solo di considerazioni... che ne stimolano altre (o pareri).
Mi si faceva notare che il ritorno della funzione
    A f(const A&)
è assegnabile, mentre non lo è quello di
    const A f(const A&)
Ebbene, prendo atto.
Come mai se A = int le cose non funzionano?
Notate che anche il risultato di
    A& f(const A&)
è assegnabile... e funziona anche nel caso in cui A = int.
Il perché me lo posso spiegare, ma la ragione è un po' contorta.
Considerate, dal punto di vista sintattico, CHE COSA potete ritornare in una
funzione che ritorni, come nell'ultimo caso, A&.
C'è una controparte semantica a queste limitazioni (che vi invito a
trovare).
Dal punto di vista delle classi, per il significato di "valore" di
un'istanza della classe, soprattutto agli occhi del compilatore, è possibile
assegnare qualcosa a un oggetto non accessibile dall'ambiente.
Mi spiego meglio.
Si abbiano le seguenti dichiarazioni:
    A operator+(const A&, const A&);
    A a,b,c;
Come mi si è dimostrato, è possibile scrivere
    (a+b) = c;
Dopo quest'istruzione, in che modo sarà possibile accedere al valore appena
assegnato (a parte tramite c!!!)?
La risposta è "boh, non importa, tanto il linguaggio non è funzionale, per
cui la valutazione di questa istruzione ha già ottenuto i suoi scopi, if
any".
A me 'sta cosa puzza... ma prendo atto.
Notate che, apparentemente, lo stesso problema si pone nel momento in cui ho
dichiarato l'operatore come
    A& operator+(const A&, const A&);
con la -non banale- differenza che per poter ritornare un A&, io devo fare
riferimento a qualcosa introdotto sia nell'AMBIENTE che nella MEMORIA; nel
caso invece di
    A operator+(const A&, const A&)
posso anche ritornare un'istanza "al volo", cioè costruendola all'interno
della funzione.
Potrebbe sembrare che si stia parlando del sesso degli angeli, ma la cosa
non è affatto priva di significato, se si considera che la situazione è
analoga al ritorno di puntatori.
Che succede se scrivo una cosa del genere?
    int * f() {
        int arr[3];
        arr[0] = 3;
        arr[1] = 5;
        arr[2] = 76;
    }
    int pippo() {
        int *m;
        m = f();
        return m[1];
    }
Tutto questo compila (gcc version egcs-2.91.66 19990314/Linux (egcs-1.1.2
release), Borland C++Builder Version 4.0 (Build 14.11) Update Pack 1), ma è,
quantomeno, di dubbio gusto.
Questo genera un warning:
    int & f() {
        int a;
        a = 5;
        return a;
    }
(e meno male!!)  warning: reference to local variable `a' returned
Ma questo:
    int & g(int a) {
        a = 5;
        return a;
    }
passa tranquillamente!!! (Notate che potrei invocare g(7) = 5, che
succerebbe?).
Ogni commento è molto ben accetto!
Cordiali salumi,
    Rony.

     Rony.
ciao
Franz

Ogni commento è molto ben accetto!
Benvenuto all'inferno ;)
Scherzi a parte credo che quelli che hai mostrato non siano
errori che un programmatore che ha compreso le basi del C++
possa commettere facilmente.
In C++ purtroppo ci sono trappole piu' subdole in cui e' piu'
facile cadere e su cui i compilatori difficilmente possono
aiutare piu' di tanto (ad es. l'uso di iteratori invalidati).
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 aiutare piu' di tanto (ad es. l'uso di iteratori invalidati).
Mmh... mi sa di ritorno per VALORE di oggetti (ammesso e non concesso che
non siano typedef di A*...)  creati localmente a un metodo... o sbaglio? ;P
A questo punto una domanda tormenta la mia anima: ma i sistemi operativi
"rasta", secondo voi, supportano in modo nativo il MULTIDREAD?
(Ok, lapidatemi!).
Cordiali salumi,
    Rony.

(Ok, lapidatemi!).
Penso di aver capito a quale delle due meta' degli studenti secondo
la classificazione di Veronesi appartieni :)


 relativa al multithreading.
Senso dello humour == NULL. Era una battuta ;)