Czy można zapobiec pominięciu elementów inicjujących agregację?

Mam strukturę z wieloma członkami tego samego typu, jak ten

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

Problem polega na tym, że jeśli zapomnę zainicjować jednego z elementów struktury (np. wasactive), To tak:

VariablePointers{activePtr, filename}

Kompilator nie będzie na to narzekał, ale będę miał częściowo zainicjowany obiekt. Jak mogę zapobiec tego rodzaju błędom? Mógłbym dodać konstruktor, ale skopiowałby listę zmiennych dwukrotnie, więc muszę trzykrotnie wpisać to wszystko!

Dodaj również odpowiedzi C ++ 11 , jeśli istnieje rozwiązanie dla C ++ 11 (obecnie jestem ograniczony do tej wersji). Mile widziane są jednak nowsze standardy językowe!

Oto sztuczka, która wyzwala błąd linkera, jeśli brakuje wymaganego inicjalizatora:

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

Stosowanie:

struct Foo {
    int bar = init_required;
};

int main() {
    Foo f;
}

Wynik:

/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

Ostrzeżenia:

• Przed wersją C ++ 14 Foow ogóle nie jest to agregat.
• To technicznie zależy od nieokreślonego zachowania (naruszenie ODR), ale powinno działać na każdej rozsądnej platformie.

W przypadku clang i gcc można skompilować, -Werror=missing-field-initializersco powoduje, że ostrzeżenie o brakujących inicjatorach pól zmienia się w błąd. godbolt

Edycja: W przypadku MSVC wydaje się, że nie jest emitowane żadne ostrzeżenie nawet na poziomie /Wall, więc nie sądzę, że możliwe jest ostrzeżenie o brakujących inicjalizatorach za pomocą tego kompilatora. godbolt

Chyba nie jest to eleganckie i poręczne rozwiązanie ... ale powinno również działać z C ++ 11 i dawać błąd czasu kompilacji (nie łącza).

Chodzi o to, aby dodać do struktury dodatkowy element członkowski, na ostatniej pozycji, typu bez domyślnej inicjalizacji (i który nie może zainicjować wartością typu VariablePtr(lub jakikolwiek typ poprzednich wartości)

Przez przykład

struct bar
 {
   bar () = delete;

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

   bar (int) 
    { }
 };

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

   bar sentinel;
 };

W ten sposób jesteś zmuszony dodać wszystkie elementy do swojej zagregowanej listy inicjalizacyjnej, w tym wartość do jawnego zainicjowania ostatniej wartości (liczba całkowita sentinel, w przykładzie) lub otrzymujesz błąd „wywołanie usuniętego konstruktora błędu”.

Więc

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

skompiluj i

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

nie.

Niestety także

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

nie kompiluje się.

-- EDYTOWAĆ --

Jak wskazali MSalters (dzięki), w moim oryginalnym przykładzie występuje wada (kolejna wada): barwartość może być zainicjowana charwartością (którą można przekształcić int), więc działa następująca inicjalizacja

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

i może to być bardzo mylące.

Aby uniknąć tego problemu, dodałem następujący konstruktor usuniętych szablonów

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

więc poprzednia f4deklaracja podaje błąd kompilacji, ponieważ dwartość jest przechwytywana przez konstruktor szablonu, który jest usuwany

W przypadku CppCoreCheck istnieje reguła sprawdzająca dokładnie, czy wszystkie elementy zostały zainicjowane i które można przekształcić z ostrzeżenia w błąd - zwykle dotyczy to całego programu.

Aktualizacja:

Reguła, którą chcesz sprawdzić, jest częścią bezpieczeństwa typów Type.6:

Typ 6: Zawsze inicjuj zmienną składową: zawsze inicjuj, prawdopodobnie używając domyślnych konstruktorów lub domyślnych inicjatorów składowych.

Najprostszym sposobem jest nie nadanie typowi elementów konstruktora bez argumentu:

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 

Inna opcja: jeśli Twoi członkowie są const &, musisz zainicjować ich wszystkich:

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

Jeśli możesz żyć z jednym manekinem const i członkiem, możesz połączyć to z pomysłem @ max66 na wartownika.

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

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

Jeśli liczba klauzul inicjalizujących jest mniejsza niż liczba elementów lub lista inicjalizująca jest całkowicie pusta, pozostałe elementy są inicjowane pod względem wartości. Jeśli członkiem typu odniesienia jest jeden z tych pozostałych członków, program jest źle sformułowany.

Inną opcją jest wzięcie pomysłu wartownika max66 i dodanie cukru syntaktycznego dla czytelności

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