การเริ่มต้นโครงสร้าง C ++ ที่สะดวก

ฉันกำลังพยายามหาวิธีที่สะดวกในการเริ่มต้นโครงสร้าง C ++ 'pod' ตอนนี้พิจารณาโครงสร้างต่อไปนี้:

struct FooBar {
  int foo;
  float bar;
};
// just to make all examples work in C and C++:
typedef struct FooBar FooBar;

หากฉันต้องการเริ่มต้นสิ่งนี้อย่างสะดวกใน C (!) ฉันสามารถเขียน:

/* A */ FooBar fb = { .foo = 12, .bar = 3.4 }; // illegal C++, legal C

โปรดทราบว่าฉันต้องการหลีกเลี่ยงสัญกรณ์ต่อไปนี้อย่างชัดเจนเพราะมันทำให้ฉันรู้สึกว่าถูกทำให้คอหักถ้าฉันเปลี่ยนแปลงอะไรในโครงสร้างในอนาคต:

/* B */ FooBar fb = { 12, 3.4 }; // legal C++, legal C, bad style?

เพื่อให้บรรลุสิ่งเดียวกัน (หรืออย่างน้อยก็คล้ายกัน) ใน C ++ ดังใน/* A */ตัวอย่างฉันจะต้องใช้ตัวสร้างงี่เง่า:

FooBar::FooBar(int foo, float bar) : foo(foo), bar(bar) {}
// ->
/* C */ FooBar fb(12, 3.4);

ซึ่งดีสำหรับการต้มน้ำ แต่ไม่เหมาะสำหรับคนขี้เกียจ (ความขี้เกียจเป็นสิ่งที่ดีใช่มั้ย?) นอกจากนี้มันค่อนข้างแย่พอ ๆ กับ/* B */ตัวอย่างเนื่องจากไม่ได้ระบุอย่างชัดเจนว่าค่าใดไปที่สมาชิก

ดังนั้นคำถามของฉันโดยพื้นฐานแล้วฉันจะบรรลุสิ่งที่คล้าย/* A */หรือดีกว่าใน C ++ ได้อย่างไร อีกวิธีหนึ่งฉันจะโอเคกับคำอธิบายว่าทำไมฉันไม่ควรทำสิ่งนี้ (เช่นทำไมกระบวนทัศน์ทางจิตของฉันไม่ดี)

แก้ไข

ตามสะดวกผมหมายถึงยังบำรุงรักษาและการที่ไม่ซ้ำซ้อน

การกำหนดค่าเริ่มต้นที่กำหนดไว้จะได้รับการสนับสนุนใน c ++ 2a แต่คุณไม่ต้องรอเพราะGCC, Clang และ MSVC รองรับอย่างเป็นทางการ

#include <iostream>
#include <filesystem>

struct hello_world {
    const char* hello;
    const char* world;
};

int main () 
{
    hello_world hw = {
        .hello = "hello, ",
        .world = "world!"
    };

    std::cout << hw.hello << hw.world << std::endl;
    return 0;
}

GCC Demo MSVC Demo

ตั้งแต่ style Aไม่ได้รับอนุญาตใน C ++ และคุณไม่ต้องการstyle Bแล้ววิธีการใช้style BX:

FooBar fb = { /*.foo=*/ 12, /*.bar=*/ 3.4 };  // :)

อย่างน้อยก็ช่วยได้บ้าง

คุณสามารถใช้แลมด้า:

const FooBar fb = [&] {
    FooBar fb;
    fb.foo = 12;
    fb.bar = 3.4;
    return fb;
}();

ข้อมูลเพิ่มเติมเกี่ยวกับสำนวนนี้สามารถพบได้ในบล็อกสมุนไพรซัทเทอ

คำถามของคุณค่อนข้างยากเพราะแม้แต่ฟังก์ชั่น:

static FooBar MakeFooBar(int foo, float bar);

อาจเรียกได้ว่าเป็น:

FooBar fb = MakeFooBar(3.4, 5);

เนื่องจากกฎการส่งเสริมการขายและการแปลงสำหรับประเภทตัวเลขในตัว (C ไม่เคยพิมพ์รุนแรงจริงๆ)

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

template <typename Integer, typename Real>
FooBar MakeFooBar(Integer foo, Real bar) {
  static_assert(std::is_same<Integer, int>::value, "foo should be of type int");
  static_assert(std::is_same<Real, float>::value, "bar should be of type float");
  return { foo, bar };
}

ในภาษา C คุณสามารถตั้งชื่อพารามิเตอร์ได้ แต่คุณจะไม่ไปต่อ

ในทางกลับกันหากสิ่งที่คุณต้องการคือชื่อพารามิเตอร์คุณต้องเขียนโค้ดที่ยุ่งยากมากมาย:

struct FooBarMaker {
  FooBarMaker(int f): _f(f) {}
  FooBar Bar(float b) const { return FooBar(_f, b); }
  int _f;
};

static FooBarMaker Foo(int f) { return FooBarMaker(f); }

// Usage
FooBar fb = Foo(5).Bar(3.4);

และคุณสามารถพริกไทยในการป้องกันการส่งเสริมประเภทถ้าคุณต้องการ

แยกสิ่งที่เจือปนออกเป็นฟังก์ชันที่อธิบายถึงสิ่งเหล่านี้ (การปรับโครงสร้างพื้นฐาน):

FooBar fb = { foo(), bar() };

ฉันรู้ว่าสไตล์นั้นใกล้เคียงกับที่คุณไม่ต้องการใช้มาก แต่มันช่วยให้เปลี่ยนค่าคงที่ได้ง่ายขึ้นและยังอธิบายได้ (ไม่จำเป็นต้องแก้ไขความคิดเห็น) หากพวกเขาเปลี่ยนไป

อีกสิ่งหนึ่งที่คุณทำได้ (เนื่องจากคุณขี้เกียจ) คือทำให้ตัวสร้างเป็นแบบอินไลน์ดังนั้นคุณไม่จำเป็นต้องพิมพ์มากนัก (ลบ "Foobar ::" และเวลาที่ใช้ในการสลับระหว่างไฟล์ h และ cpp):

struct FooBar {
  FooBar(int f, float b) : foo(f), bar(b) {}
  int foo;
  float bar;
};

ส่วนหน้า C ++ ของคอมไพเลอร์จำนวนมาก (รวมถึง GCC และ clang) เข้าใจไวยากรณ์ C initializer ถ้าทำได้ก็ใช้วิธีนั้น

อีกวิธีหนึ่งใน C ++ คือ

struct Point
{
private:

 int x;
 int y;

public:
    Point& setX(int xIn) { x = Xin; return *this;}
    Point& setY(int yIn) { y = Yin; return *this;}

}

Point pt;
pt.setX(20).setY(20);

ตัวเลือก D:

FooBar FooBarMake(int foo, float bar)

กฎหมาย C, กฎหมาย C ++ ปรับให้เหมาะสมสำหรับ POD ได้อย่างง่ายดาย แน่นอนว่าไม่มีอาร์กิวเมนต์ที่ตั้งชื่อ แต่ก็เหมือนกับ C ++ ทั้งหมด หากคุณต้องการอาร์กิวเมนต์ที่ตั้งชื่อ Objective C ควรเป็นทางเลือกที่ดีกว่า

ตัวเลือก E:

FooBar fb;
memset(&fb, 0, sizeof(FooBar));
fb.foo = 4;
fb.bar = 15.5f;

กฎหมาย C, กฎหมาย C ++ อาร์กิวเมนต์ที่ตั้งชื่อ

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

#define INVALID_STRUCT_ERROR "Instantiation of struct failed: Type, order or number of attributes is wrong."

#define CREATE_STRUCT_1(type, identifier, m_1, p_1) \
{ p_1 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_2(type, identifier, m_1, p_1, m_2, p_2) \
{ p_1, p_2 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_3(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3) \
{ p_1, p_2, p_3 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\

#define CREATE_STRUCT_4(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3, m_4, p_4) \
{ p_1, p_2, p_3, p_4 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_4) >= (offsetof(type, m_3) + sizeof(identifier.m_3)), INVALID_STRUCT_ERROR);\

// Create more macros for structs with more attributes...

จากนั้นเมื่อคุณมีโครงสร้างที่มีแอตทริบิวต์คุณสามารถทำได้:

struct MyStruct
{
    const int attr1;
    const float attr2;
    const double attr3;
};

const MyStruct test = CREATE_STRUCT_3(MyStruct, test, attr1, 1, attr2, 2.f, attr3, 3.);

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

แต่มันช่วยแก้ปัญหาของคุณได้: เมื่อคุณเปลี่ยนโครงสร้างการเรียกจะล้มเหลวในเวลาคอมไพล์

หากคุณใช้ C ++ 17 คุณสามารถทำให้มาโครเหล่านี้เข้มงวดขึ้นได้โดยบังคับให้ใช้ประเภทเดียวกันเช่น:

#define CREATE_STRUCT_3(type, identifier, m_1, p_1, m_2, p_2, m_3, p_3) \
{ p_1, p_2, p_3 };\
static_assert(offsetof(type, m_1) == 0, INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_2) >= sizeof(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(offsetof(type, m_3) >= (offsetof(type, m_2) + sizeof(identifier.m_2)), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_1) == typeid(identifier.m_1), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_2) == typeid(identifier.m_2), INVALID_STRUCT_ERROR);\
static_assert(typeid(p_3) == typeid(identifier.m_3), INVALID_STRUCT_ERROR);\

ทาง /* B */ดีใน C ++ นอกจากนี้ C ++ 0x จะขยายไวยากรณ์ดังนั้นจึงมีประโยชน์สำหรับคอนเทนเนอร์ C ++ ด้วย ฉันไม่เข้าใจว่าทำไมคุณถึงเรียกมันว่าสไตล์ไม่ดี?

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

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

ไวยากรณ์อะไรประมาณนี้

typedef struct
{
    int a;
    short b;
}
ABCD;

ABCD abc = { abc.a = 5, abc.b = 7 };

เพิ่งทดสอบบน Microsoft Visual C ++ 2015 และบน g ++ 6.0.2 ทำงานได้ดี
คุณสามารถสร้างมาโครเฉพาะได้เช่นกันหากคุณต้องการหลีกเลี่ยงการทำซ้ำชื่อตัวแปร

สำหรับฉันวิธีที่เกียจคร้านที่สุดในการอนุญาตให้ใช้ inline inizialization คือใช้มาโครนี้

#define METHOD_MEMBER(TYPE, NAME, CLASS) \
CLASS &set_ ## NAME(const TYPE &_val) { NAME = _val; return *this; } \
TYPE NAME;

struct foo {
    METHOD_MEMBER(string, attr1, foo)
    METHOD_MEMBER(int, attr2, foo)
    METHOD_MEMBER(double, attr3, foo)
};

// inline usage
foo test = foo().set_attr1("hi").set_attr2(22).set_attr3(3.14);

มาโครนั้นสร้างแอตทริบิวต์และวิธีการอ้างอิงตนเอง

สำหรับเวอร์ชันของ C ++ ก่อน C ++ 20 (ซึ่งแนะนำการเริ่มต้นที่มีชื่อทำให้ตัวเลือกของคุณใช้ได้ใน C ++) ให้พิจารณาสิ่งต่อไปนี้:

int main()
{
    struct TFoo { int val; };
    struct TBar { float val; };

    struct FooBar {
        TFoo foo;
        TBar bar;
    };

    FooBar mystruct = { TFoo{12}, TBar{3.4} };

    std::cout << "foo = " << mystruct.foo.val << " bar = " << mystruct.bar.val << std::endl;

}

โปรดทราบว่าหากคุณพยายามเริ่มต้นโครงสร้างด้วย FooBar mystruct = { TFoo{12}, TFoo{3.4} };คุณจะได้รับข้อผิดพลาดในการคอมไพล์

ข้อเสียคือคุณต้องสร้างหนึ่ง struct mystruct.foo.valเพิ่มเติมสำหรับแต่ละตัวแปรภายในโครงสร้างหลักของคุณและคุณจะต้องใช้ค่าภายในด้วย แต่ในทางกลับกันมันสะอาดเรียบง่ายบริสุทธิ์และได้มาตรฐาน