[C++] Costruttore di copia

[ped451]

Volevo sapere se questa implementazione del costruttore di copia è giusta:
TextLine::TextLine(const TextLine &textline)
: mTokens(textline.mTokens)
{
for(int i=0; i<mTokens.size(); ++i)
mTokens[i] = textline.mTokens[i];

}

Qui di seguito vi metto la classe di riferimento.


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

Ve lo chiedo perchè il compilatore nn mi da errori di sintassi ma vorrei sapere se effettivamente funziona, e se per favore mi potete indicare un modo per verificarlo. Grazie anticipatamente!!!!

[mondobimbi]

TextLine text = TextLine("pippo");

dovrebbe bastare per provarlo.
L'operatore di assegnazione lo devi definire solo se hai un costruttore senza argomenti

TextLine::TextLine();

TextLine text ;
text = TextLine("pippo");

ciao
sergio

[ped451]

ok grazie funziona...e per quanto riguarda il distruttore??? io scrivo:

delete mTokens;

ma lui mi da un errore:
..\textAnalayzer\li2TextDoc.cpp type `class std::vector<li2::TextToken*, std::allocator<li2::TextToken*> >' argument given to `delete', expected pointer

ma mTokens è un pointer!!! è inizializzato così: vector<TextToken*> mTokens!!!!

[mondobimbi]

mTokens è un oggetto non un puntatore e sarà rilasciato automaticamente.

[ped451]

Quindi il delete lo devo fare di textline?

[mondobimbi]

textline chi è ?

Se è questo sì
TextLine * textline = new TextLine ( "prova" ) ;

se invece è questo no
TextLine textline( "prova" ) ;

[ped451]

textline è questo: TextLine(const TextLine &textline)//costruttore di copia;

io sto facebdo l'implementazione del distruttore della classe TextLine:
TextLine::~TextLine()
{
delete [] ....
}
nn riesco a capire cosa devo scrivere dopo il delete, a quale puntatore devo far riferimento

[mondobimbi]

innazitutto textline (tutto minuscolo) è una cosa completamente diversa da TextLine.
TextLine è una classe, quello che devi rilasciare è una istanza della classe allocata dinamicamente

TextLine * textline = new TextLine ( "prova" ) ;
delete textline;

il distruttore di TextLine si occupa di rilasciare la memoria allocata durante l'istanza della classe (se qualcosa è stato allocato), altrimenti distrugge solo l'oggetto stesso.

TextLine::~TextLine ()
{

}

[ped451]

quindi nn devo scriverci nulla?!
questa è la classe:

TextLine(const string &text);


TextLine(const TextLine &textline);
~TextLine();
TextLine &operator=(const TextLine &textline);
string getText();

size_t getTokenCount() const;

TextToken *getToken(size_t i) const;

private:

vector<TextToken *> mTokens
};

ma quello che viene instanziato nn è mTokens? quindi nn lo devo far in modo di rilasciare poi la sua memoria?!

[mondobimbi]

vector<TextToken *> mTokens

mTokens non è un puntatore ma un oggetto della classe vector instanziato staticamente quindi la sua memoria sarà rilasciata automaticamente quando verrà disallocato l'oggetto della classe che lo contiene.
Se non hai altri membri nella classe il distrutturo della classe TextLine non deve fare niente, puoi anche ometterlo.