[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;
}