Perplessità nel passaggio di oggetti e loro allocazione nello stack

[Emalele1688]

Buogiorno a tutti:D
Questa mattina mi sono svegliato con un dubbio ed ho pensato di postare il problema con un esempio:

Se io ho una classe (nell' esempio ho Player)

class Player
{
public:
Player(char* s, int v) : name(s), life(v)
{}

Player& operator=(const Player& op)
{
if(&op == this)
return *this;

name = op.name;
return *this;
}

//Sono publici solo per risparmiare spazio e tempo nell'esempio
int life;
char* name;

};

poi nel main scrivo in una std::list<Player> e gli inserisco dei giocatori quindi

list<Player> l;
l.push_back(Player("P1", 2));
l.push_back(Player("P2", 4));
l.push_back(Player("P3", 1));


Nello stack del main continuano ad esistere i 3 oggetti Player (non più raggiungibili da riferimenti), oppure al metodo push_back è passato solo il costruttore?
push_back si servirà dell'overloading dell'operatore= per mettere nella lista l'istanza di Player?

[Emalele1688]

Ok mi do la soluzione da solo che ho capito ora.
Scrivendo questo:
l.push_back(Player("P1", 2));
succede:
Viene creato un oggetto Player in una locazione temporanea, una reference a questa locazione è passata al metodo di list, push_back(const E& e), che la copia nella lista, e la locazione temporanea viene distrutta mediante l'apposito distruttore.

Ora però, per quale motivo la locazione temporanea e l'oggetto Player presente nella list si creano mediante il costruttore copia invece di invocare l'operatore=?
In quale caso in un oggetto ce assoluto bisogno di una corretta ridefinizione dell'operatore= ?

[Floris]

Se non sbaglio:
- l'assegnazione si usa quando si ha a=b con a e b dello stesso tipo o ... (casi più complicati dovuti ai sottotipi) ed a è GIA' stato definito.
- la copia si ha quando un oggetto viene dichiarato ED inizializzato con un oggetto dello stesso tipo, o quando l'oggetto viene passato per valore ad una funzione, o quando viene ritornato come valore da una funzione.
Poi da quel che ricordo alcune ottimizzazioni permettono di evitare la creazione di oggetti temporanei e quindi uqalche invocazione del costruttore di copia.

In ogni caso la cosa migliore che puoi fare è ridefinirti copia ed assegnazione mettendoci qualche istruzione di stampa e fare alcune prove. Questo ti aiuterà a toglierti qualche dubbio. Ricorda anche di aggiungere l'opzione al compilatore che evita le ottimizzazioni (-fno-elide-constructors nel g++).

[Emalele1688]

Ho fatto così (il codice è un po sporco)

#include <stdio.h>
#include <list>

class Player
{
public:
Player(char* s, int l) : name(s), life(l)
{}

~Player()
{
printf("Ti distruggo %s\n", name);
}

Player& operator=(const Player& op)
{
if(&op == this)
return *this;

name = op.name;
return *this;
}

int life;
char* name;

};

using namespace std;

int main(void)
{
printf("Hy guy!\n");
list<Player> l;
l.push_back(Player("Gand", 2));
l.push_back(Player("rand", 4));
l.push_back(Player("Land", 1));

printf("Usciamo e distruggiamo tutto che è sempre meglio\n");

return 0;
}


l'output è:

[emanuele@myhost ~]$ ./pro
Hy guy!
Ti distruggo Gand
Ti distruggo rand
Ti distruggo Land
Usciamo e distruggiamo tutto che è sempre meglio
Ti distruggo Gand
Ti distruggo rand
Ti distruggo Land

Questo prova ciò che dicevo.
Di default il compilatore crea una variabile temporanea che distrugge subito dopo la sua copia nella lista. Dubbio risolto:)

[LMCH]

Ora però, per quale motivo la locazione temporanea e l'oggetto Player presente nella list si creano mediante il costruttore copia invece di invocare l'operatore=?
In quale caso in un oggetto ce assoluto bisogno di una corretta ridefinizione dell'operatore= ?

Per default copia ed assegnazione sono uguali e fanno una "shallow copy" (copia superficiale, viene copiato "il blocco di memoria" con i dati dell'oggetto e quindi se l'oggetto contiene puntatori o handle li copia tali e quali).
Se hai esigenze particolari (tipo: vuoi dare una "deep copy" in cui fai dei doppioni degli oggetti puntati e crei nuovi handle distinti) devi ridefinire i due metodi.

[british]

Per default copia ed assegnazione sono uguali e fanno una "shallow copy" (copia superficiale, viene copiato "il blocco di memoria" con i dati dell'oggetto e quindi se l'oggetto contiene puntatori o handle li copia tali e quali).
Se hai esigenze particolari (tipo: vuoi dare una "deep copy" in cui fai dei doppioni degli oggetti puntati e crei nuovi handle distinti) devi ridefinire i due metodi.

e solitamente anche il distruttore: è la cosiddetta "Rule of Three" (http://en.wikipedia.org/wiki/Rule_of_three_%28C%2B%2B_programming%29)

ciao!

british

[Emalele1688]

Bè, dire che è d'obbligo sovrascrivere il distruttore quando crei allocazioni dinamiche.