[C++] Operatore di assegnamento overloaded

[oppid]

Ciao ragazzi, nn riesco a spiegarmi una cosa e sicurmente qualcuno di voi può darmi una mano.

Ho creato una classe di nome Lobby

class Lobby
{
    friend ostream& operator<<(ostream& os, const Lobby& aLobby);
    
public:
    Lobby();
    ~Lobby();
    Lobby(const Lobby& aLobby);
    Lobby& Lobby::operator=(const Lobby& aLobby); 
    void AddPlayer();
    void RemovePlayer();
    void Clear();
    
private:
    Player* m_pHead;  
};

è praticamente una lista linkata di Player.
Come si può vedere dal codice ho sovraccaricato l'operatore di assegnamento e il costruttore di copia.
In seguito ho definito una funzione per il test dell'assegnamento

void testAssignOp(Lobby& aLobby)
{
	//Lobby lobby = aLobby; //ERRATO, richiama il Copy Constructor
	Lobby lobby;
	lobby = aLobby; //giusto richiama l'operatore = overloaded
	cout << "Lobby copiata:\n" << lobby;
	cout << endl;
}

Non riesco a capire perchè se scrivo

Lobby lobby = aLobby;

mi richiama il costruttore copia

mentre se scrivo

Lobby lobby;
lobby = aLobby;

mi richiama l'operatore di assegnamento sovraccaricato.

Illuminatemi vi prego

[shodan]

"Sovraccaricato" in C++ indica tutt'altra cosa e non quello che intendi tu. Qui hai solo provveduto a definire le funzioni necessarie a copia e assegnamento, che per gli oggetti in C++ sono cose distinte.

Si parla di copia quando un oggetto a sinistra del segno = è in fase di costruzione e deve prelevare dati da un oggetto fatto e finito.

Lobby lobby = aLobby;

Si parla di assegnamento quando un oggetto a sinistra del segno = è un oggetto fatto e finito (anche appena costruito), e deve prelevare dati da un altro oggetto fatto e finito.

Lobby lobby;
lobby = aLobby;

Tra l'altro l'operazione di copia, che usa il segno =, è una concessione del linguaggio in quanto ricorda l'inizializzazione tra tipi di dato semplici (ong, int etc.)
Per evitare ambiguità, molti preferiscono usare:

Lobby lobby(aLobby);

per rendere meglio il concetto.

[oppid]

Ok, ho capito la differenza, ma perchè non si può dire che l'operatore di assegnamento è stato sovraccaricato?

Forse non mi sono spiegato bene, ma in un'altra parte del codice ho anche definito operator=

Lobby& Lobby::operator=(const Lobby& aLobby)
{
	cout << "Assign Op called\n";
	//libero la memoria della prima lista
	this->Clear();
	if(aLobby.m_pHead == 0)
	{
		m_pHead = 0;
	}

	else
	{
		Player* pCopy = aLobby.m_pHead;
		Player** p = &m_pHead;
		*p = new Player(pCopy->GetName());
		while(pCopy->GetNext() != 0)
		{
			pCopy = pCopy->GetNext();
			Player* newP = new Player(pCopy->GetName());
			(*p)->SetNext(newP);
			p = &newP;
		}
	}

	return *this;
}

ma allora perchè nn si può parlare di operatore overloaded?

[shodan]

Devi avere almeno due operatori di assegnamento per parlare di operatore overloaded.
E il costruttore di copia non è un operatore di assegnamento.

class Lobby
{
    friend ostream& operator<<(ostream& os, const Lobby& aLobby);
    
public:
    Lobby();
    ~Lobby();
    Lobby(const Lobby& aLobby);
    Lobby& operator=(const Lobby& aLobby); 
    Lobby& operator=(const Player* rhs); // <- questo è un operatore overloaded 
    void AddPlayer();
    void RemovePlayer();
    void Clear();
    
private:
    Player* m_pHead;  
};

[oppid]

posso chiederti un'ultima cosa?
puoi leggere questa pagina: http://www.ba.infn.it/~zito/jsem/lez2c.html.
Qui definiscono il "sovraccarico" degli operatori numerici e dell'operatore di assegnamento per gestire le operazioni con i numeri complessi.
Mi sembra che facciano come me, e allora perchè nel loro codice c'è un sovraccaricamento mentre nel mio no??

[shodan]

404 not found

[oppid]

http://www.ba.infn.it/~zito/jsem/lez2c.html

[shodan]

Nemmeno li c'è questo "sovraccarico". E il fatto che in fondo ci sia scritto: Imparate C++ in 3 giorni, credo il più complesso linguaggio attualmente esistente, da molto da pensare.
Al di la delle mie opinioni in merito, che lasciano il tempo che trovano, ribadisco quanto detto prima: per parlare di sovraccarico dell'operatore di assegnazione devi avere almeno due operatori di assegnazione. Il fatto che incidentalmente il costruttore di copia permetta di usare il segno = per copiare un oggetto da uno esistente è solo per omogeneità.
L'idea alla base è che se vale una istruzione tipo:

int i=10;
int k = i + 10;

la stessa sintassi deve valere per un oggetto.
Tra l'altro la sintassi:

int i(10);
int k(i + 10);

basterebbe da sola a rompere il presunto sovraccarico.

[oppid]

Non avevo letto che c'era scritto così. Cmq nn lo sto imparando da lì (non sono così pazzo), ma da un libro (Beginning C++: through Game Programming di Michael Dawson) e siccome non ero riuscito a spiegarmi bene come funzionasse questo sovraccaricamento (perchè anche nel libro c'è una sola definizione dell'operatore di assegnamento e lo chiama "overloaded assignment op def") ho cominciato a cercare sul web, e anche qui il senso è lo stesso http://www.bo.cnr.it/corsi-di-inform...0Overload.html

Io vengo da Java e per overloading anche io ho in mente quello che dici tu, però lo capisco con i metodi, ma per gli operatori è una cosa nuova per me.

Cmq adesso, il fatto che mi richiamasse il costruttore copia al posto dell'operatore di assegnamento che avevo definito mi è chiarissimo. Devo solo cercare di fare maggiore chiarezza sul termine overloading, magari cerco pure su qualche altro libro. A breve mi dovrebbe arrivare "Accelerated C++" di cui molti hanno espresso un'ottima opinione.
Grazie. Ciao.

[shodan]

Capita spesso che la particolare sisttassi di copia confonda le idee. Personalmente ho adottato da tempo la seconda sintassi, proprio per chiarire meglio il concetto che si tratta di copia e non di assegnazione.
Comunque se proprio si ha voglia di fare le pulci sulla questione, c'è da dire che per default il C++ crea implicitamente un operatore di assegnamento e un costruttore di copia, quindi si potrebbe parlare di overloading prendendola molto alla larga. In realtà tu definisci un operatore di assegnamento "sovrascrivendo" quello implicito del compilatore, e fai il sovraccarico del tuo operatore di assegnamento con un altro operatore di assegnamento sempre definito da te.
Si potrebbe dire che sono sfumature, ma in C++ sono importanti anche quelle.