[C++] Funzione restituisce riferimento a oggetto proprio

[ubanton]

Raga,
vi posto questo codice : sto studiando l'overloading degli operatori

Table::Table(const Table &t){
p=new char[size=t.size];
for (int i=0; i<size; i++)
p[i]=t.p[i];

const Table& Table::operator= (const Table & t){
if(this != &t) { //self assignment!
delete [] p;
p=new char[size=t.size];
for (int i=0; i<size; i++)
p[i]=t.p[i];
}
return *this;
}
la classe viene definita nel file di specifica che non ho scritto, ma il dubbio è modifico l'oggetto proprio t nella seconda parte con p[i]=t.p[i]; e faccio return *this, ma se il riferimento èconst Table& Table io non potrei modificarlo e invece lo modifico(o forse non posso modificare l'oggetto a mezzo del riferimento che poi come sarebbe?)

2- ma this(puntatore all'oggetto proprio non dovrebbe avere lo stesso indirizzo di t, quindi il programma non dovrebbe nemmeno andare avanti,dove mi sbaglio?

[__ZERO_UNO__]

Non stai modificando t ma l'oggetto *this.


Table t1, t2;
t1 = t2; // operatore =. Equivale a t1.operator=(t2)


Quindi quando viene usato l'operatore = il parametro formale t è t2 non t1, cioè l'oggetto che subisce l'assegnamento. Se fai t1 = t1 la condizione del if è falsa.
Penso sia buona norma considerare la possibile eccezione bad_alloc, non tanto per questo esempio ma per capire i momenti in cui serve in fase di apprendimento.


const Table& Table::operator= (const Table & t){
if(this != &t)
{ // i due oggetti differiscono
char* old_p = p;
size_t old_size = size;
p = 0;
try
{
// l'assegnamento di size potrebbe sfuggire scritto qui
p = new char[size=t.size];
} catch (std::bad_alloc e)
{
// si ristabilisce lo stato iniziale. Sarà il chiamante che
// deciderà cosa fare.
delete[] p;
p = old_p;
size = old_size;
throw std::bad_alloc;
}
for (int i=0; i<size; i++)
p[i]=t.p[i];
}
return *this;
}