La regola del 5: usarlo o no?

La regola di 3 ( la regola di 5 nel nuovo standard c ++) afferma:

Se è necessario dichiarare esplicitamente il distruttore, il costruttore della copia o l'operatore di assegnazione della copia, è necessario dichiarare esplicitamente tutti e tre.

D'altra parte, il " codice pulito " di Martin consiglia di rimuovere tutti i costruttori e i distruttori vuoti (pagina 293, G12: Clutter ):

A che serve un costruttore predefinito senza implementazione? Tutto ciò che serve è ingombrare il codice con artefatti insignificanti.

Quindi, come gestire queste due opinioni opposte? I costruttori / distruttori vuoti dovrebbero davvero essere implementati?

Il prossimo esempio dimostra esattamente cosa intendo:

#include <iostream>
#include <memory>

struct A
{
    A( const int value ) : v( new int( value ) ) {}
    ~A(){}
    A( const A & other ) : v( new int( *other.v ) ) {}
    A& operator=( const A & other )
    {
        v.reset( new int( *other.v ) );
        return *this;
    }

    std::auto_ptr< int > v;
};
int main()
{
    const A a( 55 );
    std::cout<< "a value = " << *a.v << std::endl;
    A b(a);
    std::cout<< "b value = " << *b.v << std::endl;
    const A c(11);
    std::cout<< "c value = " << *c.v << std::endl;
    b = c;
    std::cout<< "b new value = " << *b.v << std::endl;
}

Compila bene usando g ++ 4.6.1 con:

g++ -std=c++0x -Wall -Wextra -pedantic example.cpp

Il distruttore per struct Aè vuoto e non proprio necessario. Quindi, dovrebbe essere lì o dovrebbe essere rimosso?

Per cominciare la regola dice "probabilmente", quindi non si applica sempre.

Il secondo punto che vedo qui è che se devi dichiarare uno dei tre, è perché sta facendo qualcosa di speciale come allocare memoria. In questo caso, gli altri non sarebbero vuoti poiché avrebbero dovuto gestire la stessa attività (come copiare il contenuto della memoria allocata dinamicamente nel costruttore della copia o liberare tale memoria).

Quindi, in conclusione, non dovresti dichiarare costruttori o distruttori vuoti, ma è molto probabile che se uno è necessario, anche gli altri sono necessari.

Come per il tuo esempio: in tal caso, puoi lasciare fuori il distruttore. Non fa nulla, ovviamente. L'uso di puntatori intelligenti è un esempio perfetto di dove e perché la regola del 3 non regge.

È solo una guida su dove dare una seconda occhiata al tuo codice nel caso in cui potresti aver dimenticato di implementare funzionalità importanti che altrimenti avresti perso.

Non c'è davvero nessuna contraddizione qui. La regola del 3 parla del distruttore, del costruttore della copia e dell'operatore di assegnazione della copia. Zio Bob parla di costruttori vuoti di default.

Se hai bisogno di un distruttore, allora la tua classe probabilmente contiene puntatori alla memoria allocata dinamicamente e probabilmente vorrai avere un ctor di copia e uno operator=()che esegua una copia profonda. Questo è completamente ortogonale al fatto che tu abbia bisogno o meno di un costruttore predefinito.

Si noti inoltre che in C ++ ci sono situazioni in cui è necessario un costruttore predefinito, anche se è vuoto. Supponiamo che la tua classe abbia un costruttore non predefinito. In tal caso, il compilatore non genererà un costruttore predefinito per te. Ciò significa che gli oggetti di questa classe non possono essere archiviati in contenitori STL, poiché tali contenitori si aspettano che gli oggetti siano predefinibili.

D'altra parte, se non hai intenzione di mettere mai gli oggetti della tua classe in contenitori STL, un costruttore predefinito vuoto è sicuramente un disordine inutile.

Qui il tuo potenziale (*) equivalente a quello predefinito di un costruttore / assegnazione / distruttore ha uno scopo: documentare il fatto che hai avuto riguardo al problema e determinare che il comportamento predefinito era corretto. A proposito, in C ++ 11, le cose non si sono stabilizzate abbastanza per sapere se =defaultpuò servire a tale scopo.

(Esiste un altro potenziale scopo: fornire una definizione fuori linea anziché quella in linea predefinita, meglio documentare esplicitamente se si hanno motivi per farlo).

(*) Potenziale perché non ricordo un caso di vita reale in cui la regola del tre non si applicava, se dovevo fare qualcosa in uno, dovevo fare qualcosa negli altri.

Modifica dopo aver aggiunto un esempio. il tuo esempio usando auto_ptr è interessante. Stai utilizzando un puntatore intelligente, ma non uno adatto al lavoro. Preferirei scriverne uno che è - soprattutto se la situazione si presenta spesso - piuttosto che fare quello che hai fatto. (Se non sbaglio, né lo standard né il boost ne forniscono uno).

La regola di 5 è un'estensione cautelativa della regola di 3 che è un comportamento cautelativo contro un possibile uso improprio dell'oggetto.

Se hai bisogno di un distruttore, significa che hai fatto un po 'di "gestione delle risorse" diversa da quella predefinita (costruisci e distruggi solo i valori ).

Poiché copia, assegna, sposta e trasferisci in base ai valori di copia predefiniti , se non tieni solo i valori , devi definire cosa fare.

Detto questo, C ++ elimina la copia se si definisce lo spostamento ed elimina lo spostamento se si definisce la copia. Nella maggior parte dei casi è necessario definire se si desidera emulare un valore (quindi copiare cl clone la risorsa e spostare non ha senso) o un gestore risorse (e quindi spostare la risorsa, dove la copia non ha senso: la regola di 3 diventa la regola dell'altro 3 )

I casi in cui devi definire sia copia che sposta (regola del 5) sono piuttosto rari: in genere hai un "grande valore" che deve essere copiato se dato a oggetti distinti, ma può essere spostato se preso da un oggetto temporaneo (evitando un clone quindi distruggere ). È il caso dei contenitori STL o dei contenitori aritmetici.

Un caso può essere una matrice: devono supportare la copia perché sono valori, ( a=b; c=b; a*=2; b*=3;non devono influenzarsi a vicenda) ma possono essere ottimizzati supportando anche lo spostamento ( a = 3*b+4*cha un +che richiede due temporanei e genera un temporaneo: evitare cloni ed eliminazioni può essere utile)

Preferisco una diversa formulazione della regola del tre, che sembra più ragionevole, che è "se la tua classe ha bisogno di un distruttore (diverso da un distruttore virtuale vuoto) probabilmente ha anche bisogno di un costruttore di copie e di un operatore di assegnazione".

Specificarlo come relazione unidirezionale dal distruttore rende alcune cose più chiare:

1. Non si applica nei casi in cui si fornisce un costruttore di copie non predefinito o un operatore di assegnazione solo come ottimizzazione.

2. Il motivo della regola è che il costruttore di copie predefinito o l'operatore di assegnazione possono rovinare la gestione manuale delle risorse. Se gestisci manualmente le risorse, è probabile che ti sia reso conto che avrai bisogno di un distruttore per liberarle.

C'è un altro punto non ancora menzionato nella discussione: un distruttore dovrebbe essere sempre virtuale.

struct A
{
    A( const int value ) : v( new int( value ) ) {}
    virtual ~A(){}
    ...
}

Il costruttore deve essere dichiarato virtuale nella classe base per renderlo virtuale anche in tutte le classi derivate. Quindi, anche se la tua classe base non ha bisogno di un distruttore, finisci per dichiarare e implementare un distruttore vuoto.

Se inserisci tutti gli avvisi su (-Wall -Wextra -Weffc ++) g ++ ti avvertirà di questo. Ritengo sia buona norma dichiarare sempre un distruttore virtuale in qualsiasi classe, perché non si sa mai se la tua classe diventerà infine una classe base. Se il distruttore virtuale non è necessario, non danneggia. In tal caso, si risparmia tempo per trovare l'errore.