[C++] Implementazione funzione operator=(overloadiing di operatore)

[ped451]

namespace li2 {

/*------------------------------------------------------------------------------
class TextToken
Rappresenta una sequenza di caratteri (token) appartenenente a una data categoria
-----------------------------------------------------------------------------*/

class TextToken {
public:

// TextToken::Type: elenco dei tipi token di interesse

enum Type {
Word, // parola
SpaceSequence, // sequenza di spazi
PunctuationMark // simbolo di punteggiatura
} ;

// TextToken::TextToken: costruttore parametrico
// permette di costruire un oggetto TextToken a partire dal tipo e dal
// valore del token
// Il valore di un token è la sequenza di caratteri che lo compongono

TextToken(Type type, const string &value)
: mTtype(type), mValue(value) {}

Type mTtype;
string mValue;
};

/*------------------------------------------------------------------------------
class TextLine
Rappresenta una linea di testo
La linea di testo è rappresentata mediante la sequenza di TextToken in essa
contenuti
-----------------------------------------------------------------------------*/

class TextLine {
public:

// TextLine::TextLine: costruttore parametrico
// Costruisce un oggetto TextLine a partire da una stringa
// L'implementazione del costruttore suddivide la stringa text nella
// sequenza di token che la compongono

TextLine(const string &text);

// costruttore di copia
TextLine(const TextLine &textline);

// distruttore
~TextLine();

// operatore di assegnazione
TextLine &operator=(const TextLine &textline);

// TextLine::getText
// restituisce il testo della linea composto a partire dalla giustapposizione dei token
// contentuti nella linea di testo
string getText();

// TextLine::getTokenCount
// restituisce il numero di token nella linea di testo
size_t getTokenCount() const;

// TextLine::getToken
// restituisce l'i-esimo token nella linea di testo
TextToken *getToken(size_t i) const;

private:
// mTokens contiene la sequenza di TextToken che compongono la linea di testo
vector<TextToken *> mTokens;

};

Questa qui sopra è la classe di riferimento.
Io volevo avere delle indicazioni su come implementare la funzione:
TextLine &TextLine:perator=(const TextLine &textline)
io pensavo di farlo in questo modo:
TextLine &TextLine:perator=(const TextLine &textline)
{
if (this == &textline) return *this;
mTokens = textline.mTokens;
for(inti=0; i<mTokens.size(); ++i)
mTokens[i] = textline.mTokens[i];
return *this;
}

Grazie in anticipo per l'aiuto.

[XWolverineX]

Se hai già un costruttore di copia, usalo nell'overloading dell'operatore.

[ped451]

Intendi così?

TextLine::TextLine(const TextLine &textline)
: mTokens(textline.mTokens)
{
for(int i=0; i<mTokens.size(); ++i)
mTokens[i] = textline.mTokens[i];

}
TextLine &TextLine:perator=(const TextLine &textline)
{
if (this == &textline) return *this;
mTokens(textline);
return *this;
}

grazie.

[XWolverineX]

Non vorrei dire una fesseria, ma se hai un costruttore di copia l'operatore in overloading non ti serve proprio.
Il compilatore dovrebbe capire da solo e fare la chiamata giusta alla funzione.
Prova e fammi sapere.

[ped451]

Guarda questo nn te lo so dire, so solo che essendo un progetto per l'università io devo fare queste implemetazioni. Tu mi sapresti dire se possono essere giuste?

[MacApp]

Originariamente inviato da XWolverineX
Non vorrei dire una fesseria, ma se hai un costruttore di copia l'operatore in overloading non ti serve proprio.
Il compilatore dovrebbe capire da solo e fare la chiamata giusta alla funzione.
Prova e fammi sapere.

L'operatore d'assegnamento ed il costruttore di copia sono due cose volutamente distinte. Nel costruttore si costruisce, nell'operatore d'assegnamento in generale si distrugge e si ricostruisce.
Nel seguente esempio, attenzione al punto 2 che è equivalente al punto 1: in entrambi i casi viene chiamato il costruttore, NON l'operatore d'assegnamento che invece viene chiamato al punto 3.

// 1. L'oggetto a0 viene costruito chiamando il costruttore della classe A,
// che ha per argomento la class C
C c0;
A a0 (c0); // viene chiamato A::A (C &)

// 2. equivalente a (è solo una differente sintassi,
// in tutto e per tutto equivalente alla precedente):
A a1 = c0; // viene chiamato A::A (C &)

// 3. Invece nella seguente viene chiamato l'operatore d'assegnamento:
a1 = c0; // viene chiamato l'operatore d'assegnamento (a1 già esiste, NON deve essere costruito)! 

formalmente l'operatore d'assegnamento dovrebbe contenere codice equivalente a quello del suo distruttore + quello del suo costruttore relativo, praticamente si cerca di evitare di distruggere e ricreare cose che possono sopravvivere tra le due operazioni. Nell'equivalenza bisogna tenere conto che sia nel costruttore che nel distruttore il meccanismo virtuale non è applicabile, mentre nell'operatore d'assegmaento sì (quindi in generale non basta un doppio copia/incolla).

Attenzione quindi: i punti 1 e 2 sono EQUIVALENTI in entrambi i casi viene chiamato il costruttore relativo, nel punto 3 invece viene chiamato l'operatore d'assegnamento.

[ped451]

ok quello che dici è tutto giusto, ma io nn riesco a capire che cosa ci devo mettere, nel senso che quando io scrivo l'implementazione di operator= dovrei scrivere una cosa del genere: if(mTokens) delete [] mTokens, è solo che il compilatore mi dice che mTokens nn può essere usato come bool, come faccio a ovviare a questa situazione?
Grazie