In che modo “= default” è diverso da “{}” per costruttore e distruttore predefiniti?

Inizialmente ho pubblicato questo come una domanda solo sui distruttori, ma ora sto aggiungendo considerazione sul costruttore predefinito. Ecco la domanda originale:

Se voglio dare alla mia classe un distruttore virtuale, ma altrimenti uguale a quello che genererebbe il compilatore, posso usare =default:

class Widget {
public:
   virtual ~Widget() = default;
};

Ma sembra che posso ottenere lo stesso effetto con meno digitazioni usando una definizione vuota:

class Widget {
public:
   virtual ~Widget() {}
};

Esiste un modo in cui queste due definizioni si comportano diversamente?

Sulla base delle risposte pubblicate per questa domanda, la situazione per il costruttore predefinito sembra simile. Dato che non vi è quasi alcuna differenza di significato tra " =default" e " {}" per i distruttori, allo stesso modo non esiste alcuna differenza di significato tra queste opzioni per i costruttori predefiniti? Cioè, supponendo che io voglia creare un tipo in cui gli oggetti di quel tipo saranno sia creati che distrutti, perché dovrei dire

Widget() = default;

invece di

Widget() {}

?

Mi scuso se l'estensione di questa domanda dopo la sua pubblicazione originale sta violando alcune regole SO. Pubblicare una domanda quasi identica per i costruttori predefiniti mi è sembrata l'opzione meno desiderabile.

Questa è una domanda completamente diversa quando si chiedono costruttori che distruttori.

Se il tuo distruttore lo è virtual, allora la differenza è trascurabile, come ha sottolineato Howard . Tuttavia, se il distruttore non era virtuale , è una storia completamente diversa. Lo stesso vale per i costruttori.

L'uso della = defaultsintassi per funzioni speciali dei membri (costruttore predefinito, copia / sposta costruttori / assegnazione, distruttori ecc.) Significa qualcosa di molto diverso dal semplice fare {}. Con quest'ultimo, la funzione diventa "fornita dall'utente". E questo cambia tutto.

Questa è una banale classe secondo la definizione di C ++ 11:

struct Trivial
{
  int foo;
};

Se si tenta di costruirne uno predefinito, il compilatore genererà automaticamente un costruttore predefinito. Lo stesso vale per copia / movimento e distruzione. Poiché l'utente non ha fornito nessuna di queste funzioni membro, la specifica C ++ 11 considera questa classe "banale". È quindi legale farlo, come memorizzare i loro contenuti per inizializzarli e così via.

Questo:

struct NotTrivial
{
  int foo;

  NotTrivial() {}
};

Come suggerisce il nome, questo non è più banale. Ha un costruttore predefinito fornito dall'utente. Non importa se è vuoto; per quanto riguarda le regole di C ++ 11, questo non può essere un tipo banale.

Questo:

struct Trivial2
{
  int foo;

  Trivial2() = default;
};

Ancora una volta, come suggerisce il nome, questo è un tipo banale. Perché? Perché hai detto al compilatore di generare automaticamente il costruttore predefinito. Il costruttore non è quindi "fornito dall'utente". E quindi, il tipo conta come banale, dal momento che non ha un costruttore predefinito fornito dall'utente.

La = defaultsintassi è principalmente lì per fare cose come costruttori / assegnazioni di copie, quando si aggiungono funzioni membro che impediscono la creazione di tali funzioni. Ma attiva anche un comportamento speciale dal compilatore, quindi è utile anche nei costruttori / distruttori predefiniti.

Sono entrambi non banali.

Entrambi hanno la stessa specifica noexcept a seconda della specifica noexcept delle basi e dei membri.

L'unica differenza che sto rilevando finora è che se Widgetcontiene una base o un membro con un distruttore inaccessibile o eliminato:

struct A
{
private:
    ~A();
};

class Widget {
    A a_;
public:
#if 1
   virtual ~Widget() = default;
#else
   virtual ~Widget() {}
#endif
};

Quindi la =defaultsoluzione verrà compilata, ma Widgetnon sarà un tipo distruttibile. Cioè se provi a distruggere un Widget, otterrai un errore in fase di compilazione. Ma se non lo fai, hai un programma di lavoro.

Otoh, se fornisci il distruttore fornito dall'utente , le cose non si compileranno se distruggi o meno un Widget:

test.cpp:8:7: error: field of type 'A' has private destructor
    A a_;
      ^
test.cpp:4:5: note: declared private here
    ~A();
    ^
1 error generated.

L'importante differenza tra

class B {
    public:
    B(){}
    int i;
    int j;
};

e

class B {
    public:
    B() = default;
    int i;
    int j;
};

è che il costruttore predefinito definito con B() = default;è considerato non definito dall'utente . Ciò significa che in caso di inizializzazione del valore come in

B* pb = new B();  // use of () triggers value-initialization

avrà luogo un tipo speciale di inizializzazione che non utilizza affatto un costruttore e per i tipi predefiniti ciò comporterà un'inizializzazione zero . In questo caso B(){}non avverrà. Lo standard C ++ n3337 § 8.5 / 7 dice

Inizializzare un oggetto di tipo T significa:

- se T è un tipo di classe (possibilmente qualificato in cv) (clausola 9) con un costruttore fornito dall'utente (12.1), viene chiamato il costruttore predefinito per T (e l'inizializzazione non è corretta se T non ha un costruttore predefinito accessibile );

- se T è un tipo di classe non sindacale (possibilmente qualificato in cv) senza un costruttore fornito dall'utente , allora l'oggetto è inizializzato a zero e, se il costruttore predefinito dichiarato implicitamente di T è non banale, viene chiamato quel costruttore.

- se T è un tipo di array, ogni elemento è inizializzato dal valore; - in caso contrario, l'oggetto viene inizializzato con zero.

Per esempio:

#include <iostream>

class A {
    public:
    A(){}
    int i;
    int j;
};

class B {
    public:
    B() = default;
    int i;
    int j;
};

int main()
{
    for( int i = 0; i < 100; ++i) {
        A* pa = new A();
        B* pb = new B();
        std::cout << pa->i << "," << pa->j << std::endl;
        std::cout << pb->i << "," << pb->j << std::endl;
        delete pa;
        delete pb;
    }
  return 0;
}

risultato possibile:

0,0
0,0
145084416,0
0,0
145084432,0
0,0
145084416,0
//...

http://ideone.com/k8mBrd