Ist es möglich, das Auslassen aggregierter Initialisierungsmitglieder zu verhindern?

Ich habe eine Struktur mit vielen Mitgliedern des gleichen Typs, wie diese

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

Das Problem ist, dass, wenn ich vergesse, eines der Strukturelemente (z. B. wasactive) wie folgt zu initialisieren :

VariablePointers{activePtr, filename}

Der Compiler wird sich nicht darüber beschweren, aber ich werde ein Objekt haben, das teilweise initialisiert ist. Wie kann ich diese Art von Fehler verhindern? Ich könnte einen Konstruktor hinzufügen, aber er würde die Liste der Variablen zweimal duplizieren, also muss ich das alles dreimal eingeben!

Bitte fügen Sie auch C ++ 11- Antworten hinzu, wenn es eine Lösung für C ++ 11 gibt (derzeit bin ich auf diese Version beschränkt). Neuere Sprachstandards sind jedoch ebenfalls willkommen!

Hier ist ein Trick, der einen Linkerfehler auslöst, wenn ein erforderlicher Initialisierer fehlt:

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

Verwendungszweck:

struct Foo {
    int bar = init_required;
};

int main() {
    Foo f;
}

Ergebnis:

/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

Vorsichtsmaßnahmen:

• Vor C ++ 14 wird dadurch verhindert, dass es sich Fooüberhaupt um ein Aggregat handelt.
• Dies beruht technisch auf undefiniertem Verhalten (ODR-Verletzung), sollte jedoch auf jeder vernünftigen Plattform funktionieren.

Für clang und gcc können Sie kompilieren -Werror=missing-field-initializers, wodurch die Warnung bei fehlenden Feldinitialisierern in einen Fehler umgewandelt wird. Godbolt

Bearbeiten: Für MSVC scheint selbst auf Ebene keine Warnung ausgegeben zu werden /Wall, daher glaube ich nicht, dass es möglich ist, mit diesem Compiler vor fehlenden Initialisierern zu warnen. Godbolt

Keine elegante und handliche Lösung, nehme ich an ... sollte aber auch mit C ++ 11 funktionieren und einen Fehler bei der Kompilierung (nicht bei der Verbindungszeit) verursachen.

Die Idee ist, in Ihrer Struktur an der letzten Position ein zusätzliches Element eines Typs ohne Standardinitialisierung hinzuzufügen (und das nicht mit einem Wert vom Typ initialisiert werden kann VariablePtr (oder was auch immer der Typ der vorhergehenden Werte ist).

Zum Beispiel

struct bar
 {
   bar () = delete;

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

   bar (int) 
    { }
 };

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

   bar sentinel;
 };

Auf diese Weise müssen Sie alle Elemente zu Ihrer aggregierten Initialisierungsliste hinzufügen, den Wert zum expliziten Initialisieren des letzten Werts einschließen ( sentinelim Beispiel eine Ganzzahl für ), oder Sie erhalten den Fehler "Aufruf an gelöschten Konstruktor des Balkens".

Damit

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

kompilieren und

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

nicht.

Leider auch

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

kompiliert nicht.

- BEARBEITEN -

Wie von MSalters (danke) angegeben, gibt es in meinem ursprünglichen Beispiel einen Fehler (einen weiteren Fehler): Ein barWert könnte mit einem charWert initialisiert werden (der in konvertierbar ist int), daher funktioniert die folgende Initialisierung

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

und das kann sehr verwirrend sein.

Um dieses Problem zu vermeiden, habe ich den folgenden gelöschten Vorlagenkonstruktor hinzugefügt

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

Daher f4gibt die vorhergehende Deklaration einen Kompilierungsfehler aus, da der dWert vom gelöschten Vorlagenkonstruktor abgefangen wird

Für CppCoreCheck gibt es eine Regel, mit der genau überprüft werden kann, ob alle Mitglieder initialisiert wurden und die von einer Warnung in einen Fehler umgewandelt werden kann - das ist normalerweise normalerweise programmweit.

Aktualisieren:

Die Regel, die Sie überprüfen möchten, ist Teil der Typensicherheit Type.6:

Typ.6: Immer eine Mitgliedsvariable initialisieren: Immer initialisieren, möglicherweise mit Standardkonstruktoren oder Standardelementinitialisierern.

Der einfachste Weg ist, dem Typ der Mitglieder keinen Konstruktor ohne Argumente zu geben:

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 

Eine weitere Option: Wenn Ihre Mitglieder const & sind, müssen Sie alle initialisieren:

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

Wenn Sie mit einem Dummy const & member leben können, können Sie dies mit der Idee von @ max66 eines Sentinels kombinieren.

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

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

Wenn die Anzahl der Initialisierungsklauseln geringer ist als die Anzahl der Mitglieder oder die Initialisierungsliste vollständig leer ist, werden die verbleibenden Mitglieder wertinitialisiert. Wenn ein Mitglied eines Referenztyps eines dieser verbleibenden Mitglieder ist, ist das Programm fehlerhaft.

Eine andere Möglichkeit besteht darin, die Sentinel-Idee von max66 zu übernehmen und zur besseren Lesbarkeit etwas syntaktischen Zucker hinzuzufügen

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