È possibile impedire l'omissione di membri di inizializzazione aggregati?

Ho una struttura con molti membri dello stesso tipo, come questo

struct VariablePointers {
   VariablePtr active;
   VariablePtr wasactive;
   VariablePtr filename;
};

Il problema è che se dimentico di inizializzare uno dei membri struct (ad es. wasactive), In questo modo:

VariablePointers{activePtr, filename}

Il compilatore non si lamenterà, ma avrò un oggetto parzialmente inizializzato. Come posso prevenire questo tipo di errore? Potrei aggiungere un costruttore, ma duplicerebbe due volte l'elenco di variabili, quindi devo digitare tutto questo tre volte!

Aggiungi anche le risposte C ++ 11 , se esiste una soluzione per C ++ 11 (attualmente sono limitato a quella versione). Anche gli standard linguistici più recenti sono benvenuti!

Ecco un trucco che attiva un errore del linker se manca un inizializzatore richiesto:

struct init_required_t {
    template <class T>
    operator T() const; // Left undefined
} static const init_required;

Uso:

struct Foo {
    int bar = init_required;
};

int main() {
    Foo f;
}

Risultato:

/tmp/ccxwN7Pn.o: In function `Foo::Foo()':
prog.cc:(.text._ZN3FooC2Ev[_ZN3FooC5Ev]+0x12): undefined reference to `init_required_t::operator int<int>() const'
collect2: error: ld returned 1 exit status

Avvertenze:

• Prima di C ++ 14, ciò impedisce Foodi essere un aggregato.
• Questo si basa tecnicamente su comportamenti indefiniti (violazione ODR), ma dovrebbe funzionare su qualsiasi piattaforma sana.

Per clang e gcc puoi compilare con -Werror=missing-field-initializersquello che trasforma l'avvertimento sugli inizializzatori di campo mancanti in un errore. Godbolt

Modifica: per MSVC, sembra che non ci siano avvisi emessi anche a livello /Wall, quindi non penso che sia possibile avvisare degli inizializzatori mancanti con questo compilatore. Godbolt

Non è una soluzione elegante e pratica, suppongo ... ma dovrebbe funzionare anche con C ++ 11 e dare un errore di compilazione (non link-time).

L'idea è quella di aggiungere nella struttura un membro aggiuntivo, nell'ultima posizione, di un tipo senza inizializzazione predefinita (e che non può essere inizializzato con un valore di tipo VariablePtr(o qualunque sia il tipo di valori precedenti)

Per esempio

struct bar
 {
   bar () = delete;

   template <typename T> 
   bar (T const &) = delete;

   bar (int) 
    { }
 };

struct foo
 {
   char a;
   char b;
   char c;

   bar sentinel;
 };

In questo modo sei costretto ad aggiungere tutti gli elementi nel tuo elenco di inizializzazione aggregato, incluso il valore per inizializzare esplicitamente l'ultimo valore (un numero intero sentinel, nell'esempio) o ricevi una "chiamata al costruttore cancellato dell'errore" bar ".

Così

foo f1 {'a', 'b', 'c', 1};

compilare e

foo f2 {'a', 'b'};  // ERROR

non lo fa.

Sfortunatamente anche

foo f3 {'a', 'b', 'c'};  // ERROR

non compilare.

-- MODIFICARE --

Come sottolineato da MSalters (grazie) c'è un difetto (un altro difetto) nel mio esempio originale: un barvalore potrebbe essere inizializzato con un charvalore (che è convertibile in int), quindi funziona la seguente inizializzazione

foo f4 {'a', 'b', 'c', 'd'};

e questo può essere molto confuso.

Per evitare questo problema, ho aggiunto il seguente costruttore di modelli eliminati

 template <typename T> 
 bar (T const &) = delete;

quindi la f4dichiarazione precedente genera un errore di compilazione perché il dvalore viene intercettato dal costruttore del modello che viene eliminato

Per CppCoreCheck esiste una regola per verificare esattamente che, se tutti i membri sono stati inizializzati e possono essere trasformati da avvertimento in un errore, che di solito è a livello di programma ovviamente.

Aggiornare:

La regola che si desidera verificare fa parte della sicurezza dei caratteri Type.6:

Tipo.6: inizializza sempre una variabile membro: inizializza sempre, possibilmente utilizzando costruttori predefiniti o inizializzatori membri predefiniti.

Il modo più semplice non è dare al tipo di membri un costruttore no-arg:

struct B
{
    B(int x) {}
};
struct A
{
    B a;
    B b;
    B c;
};

int main() {

        // A a1{ 1, 2 }; // will not compile 
        A a1{ 1, 2, 3 }; // will compile 

Un'altra opzione: se i tuoi membri sono const e, devi inizializzarli tutti:

struct A {    const int& x;    const int& y;    const int& z; };

int main() {

//A a1{ 1,2 };  // will not compile 
A a2{ 1,2, 3 }; // compiles OK

Se riesci a vivere con una const e un membro fittizi, puoi combinarlo con l'idea di @ max66 di una sentinella.

struct end_of_init_list {};

struct A {
    int x;
    int y;
    int z;
    const end_of_init_list& dummy;
};

    int main() {

    //A a1{ 1,2 };  // will not compile
    //A a2{ 1,2, 3 }; // will not compile
    A a3{ 1,2, 3,end_of_init_list() }; // will compile

Da cppreference https://en.cppreference.com/w/cpp/language/aggregate_initialization

Se il numero di clausole di inizializzazione è inferiore al numero di membri o l'elenco di inizializzatori è completamente vuoto, i membri rimanenti vengono inizializzati dal valore. Se un membro di un tipo di riferimento è uno di questi membri rimanenti, il programma è mal formato.

Un'altra opzione è prendere l'idea sentinella di max66 e aggiungere un po 'di zucchero sintattico per la leggibilità

struct init_list_guard
{
    struct ender {

    } static const end;
    init_list_guard() = delete;

    init_list_guard(ender e){ }
};

struct A
{
    char a;
    char b;
    char c;

    init_list_guard guard;
};

int main() {
   // A a1{ 1, 2 }; // will not compile 
   // A a2{ 1, init_list_guard::end }; // will not compile 
   A a3{ 1,2,3,init_list_guard::end }; // compiles OK