introduzione
Il C ++ tratta variabili di tipi definiti dall'utente con semantica di valore . Ciò significa che gli oggetti vengono implicitamente copiati in vari contesti e dovremmo capire cosa significa effettivamente "copiare un oggetto".
Consideriamo un semplice esempio:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(Se sei perplesso dalla name(name), age(age)parte, questo si chiama a elenco di inizializzatori del membro .)
Funzioni speciali per i membri
Cosa significa copiare un personoggetto? La mainfunzione mostra due scenari di copia distinti. L'inizializzazione person b(a);viene eseguita dal costruttore della copia . Il suo compito è costruire un nuovo oggetto basato sullo stato di un oggetto esistente. L'assegnazione b = aviene eseguita dall'operatore di assegnazione della copia . Il suo lavoro è generalmente un po 'più complicato, perché l'oggetto target è già in uno stato valido che deve essere affrontato.
Poiché non abbiamo dichiarato né il costruttore di copie né l'operatore di assegnazione (né il distruttore), questi sono implicitamente definiti per noi. Citazione dalla norma:
Il [...] costruttore di copie e l'operatore di assegnazione delle copie, [...] e il distruttore sono funzioni speciali dei membri. [ Nota : l'implementazione dichiarerà implicitamente queste funzioni membro per alcuni tipi di classe quando il programma non le dichiara esplicitamente.
L'implementazione li definirà implicitamente se vengono utilizzati. [...] nota finale ] [n3126.pdf sezione 12 §1]
Per impostazione predefinita, copiare un oggetto significa copiare i suoi membri:
Il costruttore di copie definito implicitamente per una classe X non sindacale esegue una copia membro dei suoi oggetti secondari. [n3126.pdf sezione 12.8 §16]
L'operatore di assegnazione copia implicitamente definito per una classe X non sindacale esegue l'assegnazione di copia membro dei suoi oggetti secondari. [n3126.pdf sezione 12.8 §30]
Definizioni implicite
Le funzioni membro speciali implicitamente definite per personassomigliano a questo:
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
La copia a livello di membro è esattamente ciò che vogliamo in questo caso:
namee agevengono copiati, quindi otteniamo un personoggetto indipendente e indipendente . Il distruttore definito implicitamente è sempre vuoto. Anche in questo caso va bene, dal momento che non abbiamo acquisito risorse nel costruttore. I distruttori dei membri vengono chiamati implicitamente dopo che il persondistruttore è finito:
Dopo aver eseguito il corpo del distruttore e aver distrutto qualsiasi oggetto automatico allocato all'interno del corpo, un distruttore per la classe X chiama i distruttori per i membri diretti [...] di X [n3126.pdf 12.4 §6]
Gestire le risorse
Quindi, quando dovremmo dichiarare esplicitamente quelle funzioni di membro speciale? Quando la nostra classe gestisce una risorsa , cioè quando un oggetto della classe è responsabile di quella risorsa. Questo di solito significa che la risorsa viene acquisita nel costruttore (o passata nel costruttore) e rilasciata nel distruttore.
Torniamo indietro nel tempo al C ++ pre-standard. Non c'era niente di simile std::stringe i programmatori erano innamorati dei puntatori. La personclasse avrebbe potuto apparire così:
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
Ancora oggi, le persone scrivono ancora lezioni in questo stile e si mettono nei guai: " Ho spinto una persona in un vettore e ora ho errori di memoria pazzi! " Ricorda che per impostazione predefinita, copiare un oggetto significa copiare i suoi membri, ma copiare namesemplicemente il membro copia un puntatore, non l'array di caratteri a cui punta! Ciò ha diversi effetti spiacevoli:
- Le modifiche tramite
apossono essere osservate tramiteb .
- Una volta
bdistrutto,a.name è un puntatore penzolante.
- Se
aviene distrutto, l'eliminazione del puntatore penzolante produce un comportamento indefinito .
- Poiché il compito non tiene conto di ciò che
nameindicava prima del compito, prima o poi otterrai perdite di memoria in tutto il luogo.
Definizioni esplicite
Poiché la copia membro non ha l'effetto desiderato, è necessario definire esplicitamente il costruttore della copia e l'operatore di assegnazione della copia per eseguire copie profonde della matrice di caratteri:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
Nota la differenza tra inizializzazione e assegnazione: dobbiamo eliminare il vecchio stato prima di assegnare a nameper evitare perdite di memoria. Inoltre, dobbiamo proteggere dall'autoassegnazione del modulo x = x. Senza quel controllo, delete[] nameeliminerebbe l'array contenente la stringa di origine , perché quando scrivi x = x, entrambi this->namee that.namecontengono lo stesso puntatore.
Sicurezza eccezionale
Sfortunatamente, questa soluzione fallirà se new char[...]genera un'eccezione a causa dell'esaurimento della memoria. Una possibile soluzione è quella di introdurre una variabile locale e riordinare le istruzioni:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
Questo si occupa anche di autoassegnazione senza un controllo esplicito. Una soluzione ancora più efficace a questo problema è il linguaggio copia-e-scambia , ma non entrerò nei dettagli della sicurezza delle eccezioni qui. Ho citato solo le eccezioni per evidenziare quanto segue: Scrivere classi che gestiscono le risorse è difficile.
Risorse non copiabili
Alcune risorse non possono o non devono essere copiate, come handle di file o mutex. In tal caso, dichiarare semplicemente il costruttore della copia e l'operatore di assegnazione della copia come privatesenza fornire una definizione:
private:
person(const person& that);
person& operator=(const person& that);
In alternativa, puoi ereditarli boost::noncopyableo dichiararli come eliminati (in C ++ 11 e versioni successive):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
La regola del tre
A volte è necessario implementare una classe che gestisce una risorsa. (Non gestire mai più risorse in una singola classe, questo provocherà solo dolore.) In tal caso, ricorda la regola di tre :
Se devi dichiarare esplicitamente tu stesso il distruttore, il costruttore della copia o l'operatore di assegnazione della copia, probabilmente dovrai dichiarare esplicitamente tutti e tre.
(Sfortunatamente, questa "regola" non è applicata dallo standard C ++ o da qualsiasi compilatore di cui sia a conoscenza.)
La regola del cinque
Da C ++ 11 in poi, un oggetto ha 2 funzioni membro speciali extra: il costruttore di spostamento e l'assegnazione di spostamento. La regola di cinque stati per implementare anche queste funzioni.
Un esempio con le firme:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
La regola dello zero
La regola di 3/5 viene anche definita regola del 0/3/5. La parte zero della regola indica che durante la creazione della classe è consentito non scrivere alcuna funzione del membro speciale.
Consigli
Il più delle volte, non è necessario gestire una risorsa da soli, perché una classe esistente come std::stringgià lo fa per te. Basta confrontare il semplice codice usando un std::stringmembro con l'alternativa contorta e soggetta a errori usando un char*e dovresti essere convinto. Finché stai lontano dai membri puntatori non elaborati, è improbabile che la regola del tre riguardi il tuo codice.
c++-faqtag wiki prima di votare per chiudere .