Est-il possible d'empêcher l'omission de membres d'initialisation agrégés?

J'ai une structure avec de nombreux membres du même type, comme ceci

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

Le problème est que si j'oublie d'initialiser l'un des membres de la structure (par exemple wasactive), comme ceci:

VariablePointers{activePtr, filename}

Le compilateur ne s'en plaindra pas, mais j'aurai un objet partiellement initialisé. Comment éviter ce genre d'erreur? Je pourrais ajouter un constructeur, mais cela dupliquerait la liste des variables deux fois, donc je dois taper tout cela trois fois!

Veuillez également ajouter des réponses C ++ 11 , s'il existe une solution pour C ++ 11 (actuellement, je suis limité à cette version). Les normes linguistiques plus récentes sont également les bienvenues!

Voici une astuce qui déclenche une erreur de l'éditeur de liens si un initialiseur requis est manquant:

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

Usage:

struct Foo {
    int bar = init_required;
};

int main() {
    Foo f;
}

Résultat:

/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

Mises en garde:

• Avant C ++ 14, cela empêche Foodu tout d'être un agrégat.
• Cela s'appuie techniquement sur un comportement non défini (violation ODR), mais devrait fonctionner sur n'importe quelle plate-forme saine.

Pour clang et gcc, vous pouvez compiler avec -Werror=missing-field-initializersqui transforme l'avertissement sur les initialiseurs de champ manquants en erreur. Godbolt

Edit: Pour MSVC, il ne semble y avoir aucun avertissement émis même au niveau /Wall, donc je ne pense pas qu'il soit possible d'avertir des initialiseurs manquants avec ce compilateur. Godbolt

Ce n'est pas une solution élégante et pratique, je suppose ... mais devrait également fonctionner avec C ++ 11 et donner une erreur de compilation (pas de liaison).

L'idée est d'ajouter dans votre structure un membre supplémentaire, en dernière position, d'un type sans initialisation par défaut (et qui ne peut pas s'initialiser avec une valeur de type VariablePtr(ou quel que soit le type des valeurs précédentes)

Par exemple

struct bar
 {
   bar () = delete;

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

   bar (int) 
    { }
 };

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

   bar sentinel;
 };

De cette façon, vous êtes obligé d'ajouter tous les éléments dans votre liste d'initialisation agrégée, inclus la valeur pour initialiser explicitement la dernière valeur (un entier pour sentinel, dans l'exemple) ou vous obtenez un "appel au constructeur supprimé de 'bar'".

Donc

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

compiler et

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

non.

Malheureusement aussi

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

ne compile pas.

-- ÉDITER --

Comme indiqué par MSalters (merci), il y a un défaut (un autre défaut) dans mon exemple d'origine: une barvaleur pourrait être initialisée avec une charvaleur (qui est convertible en int), donc fonctionne l'initialisation suivante

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

et cela peut être très déroutant.

Pour éviter ce problème, j'ai ajouté le constructeur de modèle supprimé suivant

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

de sorte que la f4déclaration précédente donne une erreur de compilation car la dvaleur est interceptée par le constructeur de modèle qui est supprimé

Pour CppCoreCheck, il existe une règle pour vérifier exactement cela, si tous les membres ont été initialisés et qui peuvent être transformés d'avertissement en erreur - cela est bien sûr à l'échelle du programme.

Mise à jour:

La règle que vous souhaitez vérifier fait partie de la sécurité des types Type.6:

Type.6: Toujours initialiser une variable membre: toujours initialiser, éventuellement en utilisant des constructeurs par défaut ou des initialiseurs de membres par défaut.

Le moyen le plus simple est de ne pas donner au type des membres un constructeur sans argument:

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 

Autre option: si vos membres sont const &, vous devez tous les initialiser:

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

Si vous pouvez vivre avec un membre et un constable factice, vous pouvez combiner cela avec l'idée de @ max66 d'une sentinelle.

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

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

Si le nombre de clauses d'initialisation est inférieur au nombre de membres ou que la liste d'initialisation est complètement vide, les membres restants sont initialisés en valeur. Si un membre d'un type de référence est l'un de ces membres restants, le programme est mal formé.

Une autre option consiste à prendre l'idée sentinelle de max66 et à ajouter du sucre syntaxique pour plus de lisibilité

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