Чи можна запобігти пропущенню сукупності членів ініціалізації?

У мене є структура з багатьма членами одного типу, як це

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

Проблема полягає в тому, що якщо я забуду ініціалізувати одного з членів структури (наприклад wasactive), наприклад:

VariablePointers{activePtr, filename}

Компілятор не буде скаржитися на це, але у мене буде один об’єкт, який частково ініціалізований. Як я можу запобігти подібні помилки? Я міг би додати конструктор, але він би повторював перелік змінної двічі, тому мені потрібно вводити все це тричі!

Будь ласка, додайте відповіді на C ++ 11 , якщо є рішення для C ++ 11 (наразі я обмежений цією версією). Однак новіші мовні стандарти теж вітаються!

Ось хитрість, яка запускає помилку лінкера, якщо потрібний ініціалізатор відсутній:

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

Використання:

struct Foo {
    int bar = init_required;
};

int main() {
    Foo f;
}

Результат:

/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

Застереження:

• До C ++ 14 це Fooвзагалі не дозволяє бути сукупним.
• Це технічно покладається на невизначену поведінку (порушення ODR), але має працювати на будь-якій розумній платформі.

Для clang та gcc ви можете компілювати, -Werror=missing-field-initializersщо перетворює попередження про ініціалізатори відсутніх полів на помилку. богболт

Редагувати: Для MSVC, схоже, немає попередження навіть на рівні /Wall, тому я не думаю, що за допомогою цього компілятора неможливо попередити про відсутні ініціалізатори. богболт

Я вважаю, що це не елегантне та зручне рішення ... але воно має працювати також із C ++ 11 та давати помилку під час компіляції (не час зв’язку).

Ідея полягає в тому, щоб додати в свою структуру додатковий член, в останньому положенні, типу без ініціалізації за замовчуванням (і який не може ініціалізуватися зі значенням типу VariablePtr(або яким би не був тип попередніх значень)

На прикладі

struct bar
 {
   bar () = delete;

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

   bar (int) 
    { }
 };

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

   bar sentinel;
 };

Таким чином, ви змушені додавати всі елементи до свого сукупного списку ініціалізації, включаючи значення для явної ініціалізації останнього значення (ціле число sentinel, у прикладі) або ви отримуєте помилку "виклик видаленому конструктору" бар ".

Тому

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

складати і

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

не робить.

На жаль також

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

не компілюється.

- EDIT -

Як вказує MSalters (спасибі), у моєму оригінальному прикладі є дефект (ще один дефект): barзначення можна ініціалізувати зі charзначенням (яке може бути конвертоване int), тому працює наступна ініціалізація

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

і це може бути дуже заплутано.

Щоб уникнути цієї проблеми, я додав наступний видалений конструктор шаблонів

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

тому попереднє f4оголошення дає помилку компіляції, оскільки dзначення перехоплює конструктор шаблонів, який видаляється

Для CppCoreCheck існує правило, щоб точно перевірити, якщо всі члени були ініціалізовані, і це може перетворитися з попередження в помилку - звичайно це загальнопрограмно.

Оновлення:

Правило, яке потрібно перевірити, є частиною типу безпеки Type.6:

Тип 6: Завжди ініціалізуйте змінну члена: завжди ініціалізуйте, можливо, використовуючи конструктори за замовчуванням або ініціалізатори членів за замовчуванням.

Найпростіший спосіб - не надати типу членів конструктор без аргументів:

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 

Інший варіант: Якщо ваші члени const &, ви повинні ініціалізувати їх усіх:

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

Якщо ви можете жити з одним манекеном const & member, ви можете поєднати це з ідеєю @ max66 про дозорну.

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

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

Якщо кількість пропозицій ініціалізатора менша за кількість членів або список ініціалізаторів повністю порожній, решта членів ініціалізуються за значенням. Якщо членом еталонного типу є один із цих інших членів, програма неправильно формується.

Інший варіант - взяти дозорну ідею max66 та додати трохи синтаксичного цукру для читабельності

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