เป็นไปได้หรือไม่ที่จะป้องกันไม่ให้สมาชิกเริ่มต้นรวม?

ฉันมีโครงสร้างที่มีสมาชิกประเภทเดียวกันหลายคนเช่นนี้

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

ปัญหาคือถ้าฉันลืมที่จะเริ่มต้นหนึ่งในสมาชิก struct (เช่นwasactive) เช่นนี้

VariablePointers{activePtr, filename}

คอมไพเลอร์จะไม่บ่นเกี่ยวกับมัน แต่ฉันจะมีหนึ่งวัตถุที่เริ่มต้นได้เพียงบางส่วน ฉันจะป้องกันข้อผิดพลาดประเภทนี้ได้อย่างไร ฉันสามารถเพิ่มนวกรรมิกได้ แต่มันจะทำซ้ำรายการตัวแปรสองครั้งดังนั้นฉันต้องพิมพ์ทั้งหมดสามครั้งนี้!

โปรดเพิ่มคำตอบC ++ 11หากมีวิธีแก้ปัญหาสำหรับ C ++ 11 (ขณะนี้ฉัน จำกัด เฉพาะรุ่นนั้น) อีกทั้งมาตรฐานภาษาล่าสุดก็ยินดีต้อนรับเช่นกัน!

นี่คือเคล็ดลับที่ทำให้เกิดข้อผิดพลาด linker หากไม่มี initializer ที่ต้องการ:

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ซึ่งเปลี่ยนคำเตือนเมื่อ initializers ฟิลด์ที่หายไปเป็นข้อผิดพลาด godbolt

แก้ไข:สำหรับ MSVC ดูเหมือนว่าจะไม่มีการเตือนแม้ในระดับ/Wallดังนั้นฉันไม่คิดว่าเป็นไปได้ที่จะเตือนผู้เริ่มต้นหายไปด้วยคอมไพเลอร์นี้ godbolt

ไม่ใช่โซลูชันที่สวยงามและสะดวกสบายฉันคิดว่า ... แต่ควรทำงานกับ C ++ 11 และให้ข้อผิดพลาดในการคอมไพล์เวลา (ไม่ใช่การเชื่อมโยงเวลา)

แนวคิดคือการเพิ่มสมาชิกของคุณใน struct ในตำแหน่งสุดท้ายของประเภทที่ไม่มีการกำหนดค่าเริ่มต้น (และที่ไม่สามารถเริ่มต้นด้วยค่าประเภท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

ไม่ได้รวบรวม

- แก้ไข -

ตามที่ชี้โดย MSalters (ขอบคุณ) มีข้อบกพร่อง (ข้อบกพร่องอื่น) ในตัวอย่างดั้งเดิมของฉัน: barค่าสามารถเริ่มต้นได้ด้วยcharค่า (ที่สามารถแปลงเป็นint) ได้ดังนั้นเริ่มต้นการทำงานต่อไปนี้

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

และสิ่งนี้อาจสร้างความสับสนอย่างมาก

เพื่อหลีกเลี่ยงปัญหานี้ฉันได้เพิ่มตัวสร้างเทมเพลตที่ถูกลบต่อไปนี้

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

ดังนั้นการf4ประกาศก่อนหน้านี้ให้ข้อผิดพลาดในการรวบรวมเพราะdค่าจะถูกดักจับโดยตัวสร้างแม่แบบที่จะถูกลบ

สำหรับCppCoreCheckมีกฎสำหรับการตรวจสอบอย่างชัดเจนว่าหากสมาชิกทั้งหมดได้รับการเริ่มต้นและสามารถเปลี่ยนจากการเตือนเป็นข้อผิดพลาด - ซึ่งโดยปกติจะเป็นหลักสูตรทั่วทั้งโปรแกรม

ปรับปรุง:

กฎที่คุณต้องการตรวจสอบเป็นส่วนหนึ่งของ typesafety Type.6:

Type.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 

ตัวเลือกอื่น: หากสมาชิกของคุณเป็นกลุ่ม & คุณต้องเริ่มต้นทั้งหมด:

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

หากคุณสามารถใช้ชีวิตอยู่กับสมาชิกตัวน้อยหนึ่งคนและสมาชิกคุณสามารถรวมเข้ากับแนวคิดของ @ max66 เกี่ยวกับ Sentinel

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

ถ้าจำนวนของ initializer clases น้อยกว่าจำนวนสมาชิกหรือรายการ initializer ว่างเปล่าทั้งหมดสมาชิกที่เหลือจะถูกกำหนดค่าเริ่มต้น ถ้าสมาชิกของประเภทการอ้างอิงเป็นหนึ่งในสมาชิกที่เหลือเหล่านี้โปรแกรมจะไม่ถูกต้อง

อีกทางเลือกหนึ่งคือใช้แนวคิดของ Sentinel ของ Max66 และเพิ่มน้ำตาล syntactic เพื่อให้อ่านง่าย

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