การเริ่มต้นโครงสร้าง C ++

เป็นไปได้ที่จะเริ่มต้น structs ใน C ++ ตามที่ระบุไว้ด้านล่าง

struct address {
    int street_no;
    char *street_name;
    char *city;
    char *prov;
    char *postal_code;
};
address temp_address =
    { .city = "Hamilton", .prov = "Ontario" };

ลิงก์ที่นี่และที่นี่พูดถึงว่าเป็นไปได้ที่จะใช้สไตล์นี้เฉพาะใน C เท่านั้นถ้าเป็นเช่นนั้นทำไมจึงไม่สามารถใช้ C ++ ได้? มีเหตุผลทางเทคนิคที่แฝงอยู่หรือไม่ว่าทำไมมันจึงไม่ถูกนำไปใช้ใน C ++ หรือเป็นวิธีปฏิบัติที่ไม่ดีที่จะใช้สไตล์นี้ ฉันชอบใช้วิธีการเริ่มต้นนี้เนื่องจากโครงสร้างของฉันมีขนาดใหญ่และรูปแบบนี้ทำให้ฉันสามารถอ่านได้อย่างชัดเจนว่าค่าใดถูกกำหนดให้กับสมาชิกคนใด

กรุณาแบ่งปันกับฉันหากมีวิธีอื่น ๆ ที่เราสามารถบรรลุการอ่านเดียวกัน

ฉันได้อ้างอิงลิงค์ต่อไปนี้ก่อนโพสต์คำถามนี้

1. C / C ++ สำหรับ AIX
2. โครงสร้างเริ่มต้น C กับตัวแปร
3. เริ่มต้นโครงสร้างคงที่ด้วยแท็กใน C ++
4. C ++ 11 การเริ่มต้นโครงสร้างที่เหมาะสม

หากคุณต้องการทำให้ชัดเจนว่าแต่ละค่าเริ่มต้นคือเพียงแยกมันในหลายบรรทัดด้วยความคิดเห็นในแต่ละ:

address temp_addres = {
  0,  // street_no
  nullptr,  // street_name
  "Hamilton",  // city
  "Ontario",  // prov
  nullptr,  // postal_code
};

หลังจากที่คำถามของฉันไม่มีผลลัพธ์ที่น่าพึงพอใจ (เนื่องจาก C ++ ไม่ได้ใช้ init ตามแท็กสำหรับโครงสร้าง) ฉันใช้เคล็ดลับที่พบที่นี่: สมาชิกของโครงสร้าง C ++ เริ่มต้นเป็น 0 ตามค่าเริ่มต้นหรือไม่

สำหรับคุณมันเป็นจำนวนเงินที่จะทำเช่นนั้น:

address temp_address = {}; // will zero all fields in C++
temp_address.city = "Hamilton";
temp_address.prov = "Ontario";

นี่เป็นสิ่งที่ใกล้เคียงที่สุดกับสิ่งที่คุณต้องการในตอนแรก (เป็นศูนย์ทุกฟิลด์ยกเว้นที่คุณต้องการเริ่มต้น)

ตามที่คนอื่นได้กล่าวมานี้เป็นเครื่องมือเริ่มต้นที่กำหนด

คุณลักษณะนี้เป็นส่วนหนึ่งของC ++ 20

ตัวระบุฟิลด์เป็นไวยากรณ์เริ่มต้นของ C ใน C ++ เพียงแค่ให้ค่าในลำดับที่ถูกต้องโดยไม่มีชื่อเขตข้อมูล น่าเสียดายที่นี่หมายความว่าคุณต้องให้ทั้งหมด (จริง ๆ แล้วคุณสามารถละเว้นเขตข้อมูลที่มีค่าเป็นศูนย์ต่อท้ายและผลลัพธ์จะเหมือนกัน):

address temp_address = { 0, 0, "Hamilton", "Ontario", 0 }; 

คุณลักษณะนี้เรียกว่าinitializers กำหนด มันเป็นส่วนเสริมของมาตรฐาน C99 อย่างไรก็ตามคุณลักษณะนี้ถูกทิ้งไว้ใน C ++ 11 ตามภาษาการเขียนโปรแกรม C ++ รุ่นที่ 4 ส่วนที่ 44.3.3.2 (คุณสมบัติ C ที่ไม่ได้รับการรับรองจาก C ++):

มีการเพิ่มเติมบางส่วนใน C99 (เปรียบเทียบกับ C89) โดยไม่ได้นำมาใช้ใน C ++:

[1] อาร์เรย์ที่มีความยาวแปรผัน (VLAs) ใช้เวกเตอร์หรือไดนามิกอาร์เรย์บางรูปแบบ

[2] กำหนด initializers; ใช้ตัวสร้าง

ไวยากรณ์ C99 มีค่าเริ่มต้นที่กำหนด [ดู ISO / IEC 9899: 2011, ร่างคณะกรรมการ N1570 - 12 เมษายน 2011]

6.7.9 การเริ่มต้น

initializer:
    assignment-expression
    { initializer-list }
    { initializer-list , }
initializer-list:
    designation_opt initializer
    initializer-list , designationopt initializer
designation:
    designator-list =
designator-list:
    designator
    designator-list designator
designator:
    [ constant-expression ]
    . identifier

ในทางตรงกันข้าม C ++ 11 ไม่มีinitializers ที่กำหนด [ดู ISO / IEC 14882: 2011, ร่างคณะกรรมการ N3690 - 15 พฤษภาคม 2013]

8.5 Initializers

initializer:
    brace-or-equal-initializer
    ( expression-list )
brace-or-equal-initializer:
    = initializer-clause
    braced-init-list
initializer-clause:
    assignment-expression
    braced-init-list
initializer-list:
    initializer-clause ...opt
    initializer-list , initializer-clause ...opt
braced-init-list:
    { initializer-list ,opt }
    { }

เพื่อให้บรรลุผลที่เหมือนกันใช้ constructors หรือรายการ initializer:

คุณสามารถเริ่มต้นผ่าน ctor:

struct address {
  address() : city("Hamilton"), prov("Ontario") {}
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
};

คุณยังสามารถบรรจุโซลูชันของ Gui13 ไว้ในคำสั่งเริ่มต้นเดียว:

struct address {
                 int street_no;
                 char *street_name;
                 char *city;
                 char *prov;
                 char *postal_code;
               };


address ta = (ta = address(), ta.city = "Hamilton", ta.prov = "Ontario", ta);

คำเตือน: ฉันไม่แนะนำสไตล์นี้

ฉันรู้ว่าคำถามนี้ค่อนข้างเก่า แต่ฉันพบวิธีการเริ่มต้นอีกวิธีหนึ่งโดยใช้ constexpr และ currying:

struct mp_struct_t {
    public:
        constexpr mp_struct_t(int member1) : mp_struct_t(member1, 0, 0) {}
        constexpr mp_struct_t(int member1, int member2, int member3) : member1(member1), member2(member2), member3(member3) {}
        constexpr mp_struct_t another_member(int member) { return {member1, member,     member2}; }
        constexpr mp_struct_t yet_another_one(int member) { return {member1, member2, member}; }

    int member1, member2, member3;
};

static mp_struct_t a_struct = mp_struct_t{1}
                           .another_member(2)
                           .yet_another_one(3);

วิธีนี้ยังใช้ได้กับตัวแปรคงที่ทั่วโลกและแม้กระทั่ง constexpr ข้อเสียเพียงอย่างเดียวคือความสามารถในการบำรุงรักษาที่ไม่ดี: ทุกครั้งที่สมาชิกรายอื่นต้องทำการเริ่มต้นใหม่ได้โดยใช้วิธีนี้วิธีการเริ่มต้นสมาชิกทั้งหมดจะต้องเปลี่ยน

ฉันอาจจะพลาดบางสิ่งบางอย่างที่นี่โดยทำไมไม่:

#include <cstdio>    
struct Group {
    int x;
    int y;
    const char* s;
};

int main() 
{  
  Group group {
    .x = 1, 
    .y = 2, 
    .s = "Hello it works"
  };
  printf("%d, %d, %s", group.x, group.y, group.s);
}

มันไม่ได้ใช้งานใน C ++ (ยังchar*สตริงหรือไม่ฉันหวังว่าไม่)

โดยปกติถ้าคุณมีพารามิเตอร์มากมายมันเป็นกลิ่นรหัสที่ค่อนข้างร้ายแรง แต่ทำไมไม่เพียงแค่กำหนดค่าเริ่มต้นโครงสร้างแล้วกำหนดสมาชิกแต่ละคน

ฉันพบวิธีนี้สำหรับตัวแปรทั่วโลกซึ่งไม่จำเป็นต้องแก้ไขนิยามโครงสร้างเดิม:

struct address {
             int street_no;
             char *street_name;
             char *city;
             char *prov;
             char *postal_code;
           };

จากนั้นประกาศตัวแปรประเภทใหม่ที่สืบทอดมาจากโครงสร้างดั้งเดิมและใช้ตัวสร้างสำหรับการเริ่มต้นฟิลด์:

struct temp_address : address { temp_address() { 
    city = "Hamilton"; 
    prov = "Ontario"; 
} } temp_address;

ไม่ค่อยหรูหราเท่าซีสไตล์ แต่ ...

สำหรับตัวแปรในท้องที่จะต้องมี memset เพิ่มเติม (นี่คือ 0, sizeof (* this)) ที่จุดเริ่มต้นของ Constructor ดังนั้นจึงไม่ชัดเจนและแย่กว่าและคำตอบของ @ gui13 เหมาะสมกว่า

(โปรดทราบว่า 'temp_address' เป็นตัวแปรประเภท 'temp_address' อย่างไรก็ตามประเภทใหม่นี้สืบทอดมาจาก 'ที่อยู่' และสามารถใช้งานได้ในทุกที่ที่คาดว่า 'ที่อยู่' จึงตกลง)

ฉันเผชิญกับปัญหาที่คล้ายกันในวันนี้ที่ฉันมีโครงสร้างที่ฉันต้องการกรอกข้อมูลการทดสอบซึ่งจะถูกส่งผ่านเป็นข้อโต้แย้งไปยังฟังก์ชั่นที่ฉันกำลังทดสอบ ฉันต้องการมีเวกเตอร์ของโครงสร้างเหล่านี้และกำลังมองหาวิธีการหนึ่งซับเพื่อเริ่มต้นโครงสร้างแต่ละอัน

ฉันลงเอยด้วยฟังก์ชัน constructor ใน struct ซึ่งฉันเชื่อว่ายังแนะนำในคำตอบสำหรับคำถามของคุณ

มันอาจเป็นวิธีปฏิบัติที่ไม่ดีที่จะให้อาร์กิวเมนต์แก่ตัวสร้างมีชื่อเหมือนกับตัวแปรสมาชิกสาธารณะซึ่งต้องใช้พthisอยน์เตอร์ ใครบางคนสามารถแนะนำการแก้ไขหากมีวิธีที่ดีกว่า

typedef struct testdatum_s {
    public:
    std::string argument1;
    std::string argument2;
    std::string argument3;
    std::string argument4;
    int count;

    testdatum_s (
        std::string argument1,
        std::string argument2,
        std::string argument3,
        std::string argument4,
        int count)
    {
        this->rotation = argument1;
        this->tstamp = argument2;
        this->auth = argument3;
        this->answer = argument4;
        this->count = count;
    }

} testdatum;

ซึ่งฉันใช้ในฟังก์ชั่นทดสอบของฉันเพื่อเรียกใช้ฟังก์ชันที่กำลังทดสอบด้วยอาร์กิวเมนต์ต่าง ๆ ดังนี้:

std::vector<testdatum> testdata;

testdata.push_back(testdatum("val11", "val12", "val13", "val14", 5));
testdata.push_back(testdatum("val21", "val22", "val23", "val24", 1));
testdata.push_back(testdatum("val31", "val32", "val33", "val34", 7));

for (std::vector<testdatum>::iterator i = testdata.begin(); i != testdata.end(); ++i) {
    function_in_test(i->argument1, i->argument2, i->argument3, i->argument4m i->count);
}

เป็นไปได้ แต่ถ้าโครงสร้างที่คุณกำลังเริ่มต้นเป็นโครงสร้าง POD (ข้อมูลเก่าธรรมดา) มันไม่สามารถมีวิธีการใด ๆ คอนสตรัคหรือแม้กระทั่งค่าเริ่มต้น

ใน C ++ ตัวเริ่มต้นของ C-style ถูกแทนที่ด้วยตัวสร้างซึ่งตามเวลาการคอมไพล์สามารถมั่นใจได้ว่ามีการดำเนินการเริ่มต้นที่ถูกต้องเท่านั้น (เช่นหลังจากการเริ่มต้นสมาชิกวัตถุจะสอดคล้องกัน)

เป็นวิธีปฏิบัติที่ดี แต่บางครั้งการเตรียมข้อมูลเบื้องต้นมีประโยชน์เช่นในตัวอย่างของคุณ OOP แก้นี้โดยคลาสนามธรรมหรือรูปแบบการออกแบบ Creational

ในความคิดของฉันการใช้วิธีที่ปลอดภัยนี้ฆ่าความเรียบง่ายและบางครั้งการแลกเปลี่ยนความปลอดภัยอาจมีราคาแพงเกินไปเนื่องจากรหัสง่าย ๆ ไม่จำเป็นต้องมีการออกแบบที่ซับซ้อน

ในฐานะทางเลือกอื่นฉันขอแนะนำให้กำหนดมาโครโดยใช้ lambdas เพื่อทำให้การเริ่มต้นง่ายขึ้นเพื่อให้ดูเหมือนกับสไตล์ C:

struct address {
  int street_no;
  const char *street_name;
  const char *city;
  const char *prov;
  const char *postal_code;
};
#define ADDRESS_OPEN [] { address _={};
#define ADDRESS_CLOSE ; return _; }()
#define ADDRESS(x) ADDRESS_OPEN x ADDRESS_CLOSE

แมโคร ADDRESS ขยายเป็น

[] { address _={}; /* definition... */ ; return _; }()

ซึ่งสร้างและเรียกแลมบ์ดา พารามิเตอร์มาโครจะถูกคั่นด้วยเครื่องหมายจุลภาคดังนั้นคุณต้องใส่ initializer ไว้ในวงเล็บและเรียกเช่น

address temp_address = ADDRESS(( _.city = "Hamilton", _.prov = "Ontario" ));

คุณสามารถเขียนแมโครเริ่มต้นทั่วไป

#define INIT_OPEN(type) [] { type _={};
#define INIT_CLOSE ; return _; }()
#define INIT(type,x) INIT_OPEN(type) x INIT_CLOSE

แต่สายก็สวยน้อยกว่าเล็กน้อย

address temp_address = INIT(address,( _.city = "Hamilton", _.prov = "Ontario" ));

อย่างไรก็ตามคุณสามารถกำหนดแมโคร ADDRESS โดยใช้แมโคร INIT ทั่วไปได้อย่างง่ายดาย

#define ADDRESS(x) INIT(address,x)

ใน GNUC ++ (ดูเหมือนว่าจะล้าสมัยตั้งแต่ 2.5 นานมาแล้ว :) ดูคำตอบได้ที่นี่: การเริ่มต้น C struct โดยใช้ป้ายกำกับ มันใช้งานได้ แต่อย่างไร ) มันเป็นไปได้ที่จะเริ่มต้นโครงสร้างเช่นนี้:

struct inventory_item {
    int bananas;
    int apples;
    int pineapples;
};

inventory_item first_item = {
    bananas: 2,
    apples: 49,
    pineapples: 4
};

แรงบันดาลใจจากคำตอบที่ประณีตมากนี้: ( https://stackoverflow.com/a/49572324/4808079 )

คุณสามารถทำการปิด lamba:

// Nobody wants to remember the order of these things
struct SomeBigStruct {
  int min = 1;
  int mean = 3 ;
  int mode = 5;
  int max = 10;
  string name;
  string nickname;
  ... // the list goes on
}

.

class SomeClass {
  static const inline SomeBigStruct voiceAmps = []{
    ModulationTarget $ {};
    $.min = 0;  
    $.nickname = "Bobby";
    $.bloodtype = "O-";
    return $;
  }();
}

หรือถ้าคุณต้องการที่จะแฟนซีมาก

#define DesignatedInit(T, ...)\
  []{ T ${}; __VA_ARGS__; return $; }()

class SomeClass {
  static const inline SomeBigStruct voiceAmps = DesignatedInit(
    ModulationTarget,
    $.min = 0,
    $.nickname = "Bobby",
    $.bloodtype = "O-",
  );
}

มีข้อบกพร่องบางอย่างที่เกี่ยวข้องกับเรื่องนี้ส่วนใหญ่เกี่ยวข้องกับสมาชิกที่ไม่ได้กำหนดค่าเริ่มต้น จากสิ่งที่คำตอบที่เชื่อมโยงแสดงความคิดเห็นมันรวบรวมได้อย่างมีประสิทธิภาพแม้ว่าฉันจะไม่ได้ทดสอบ

โดยรวมแล้วฉันแค่คิดว่ามันเป็นวิธีที่เรียบร้อย