在c++中，C风格的初始化式被构造函数所取代，构造函数在编译时可以确保只执行有效的初始化(即初始化后对象成员是一致的)。

这是一个很好的实践，但有时预初始化也很方便，就像在您的示例中一样。OOP通过抽象类或创建设计模式解决了这个问题。

在我看来，使用这种安全的方式消除了简单性，有时安全性的权衡可能过于昂贵，因为简单的代码不需要复杂的设计来保持可维护性。

作为另一种解决方案，我建议使用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 _; }()

它创建并调用lambda。宏参数也是用逗号分隔的，因此需要将初始化式放在括号中并调用like

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" ));

但是你可以很容易地使用INIT宏定义ADDRESS宏

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

我今天遇到了一个类似的问题，我有一个结构体，我想用测试数据填充，这些数据将作为参数传递给我正在测试的函数。我想有这些结构的一个向量，并正在寻找一个单行方法来初始化每个结构。

我最终在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);
}

我知道这个问题很老了，但我找到了另一种初始化的方法，使用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, member3}; }
        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);

此方法也适用于全局静态变量，甚至是构造变量。 唯一的缺点是糟糕的可维护性:每次必须使用此方法使另一个成员可初始化时，所有成员初始化方法都必须更改。

我发现这种方式做全局变量，不需要修改原来的结构定义:

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;

虽然没有C风格那么优雅…

对于局部变量，它需要在构造函数的开头添加一个额外的memset(this, 0, sizeof(*this))，所以它显然并不差，@gui13的答案更合适。

(注意，'temp_address'是一个'temp_address'类型的变量，但是这个新类型继承自'address'，可以在任何需要'address'的地方使用，所以它是OK的。)

你可以通过构造函数初始化:

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

你有

The standard initialization list address temp_address { /* street_no */, /* street_name */, ... /* postal_code */ }; address temp_address2 = { /* street_no */, /* street_name */, ... /* postal_code */ } The dot notation address temp_address; temp_address.street_no = ...; temp_address.street_name = ...; ... temp_address.postal_code = ...; The designated aggregate initialization, where the initialization list contains that labels of each member of the structure (see documentation) available from C++20 onward. Treating a struct like a C++ class - in C++ structures are actually special types of classes, where all members are public (unlike a standard C++ class where all members are private if not specified otherwise explicitly) as well as that when using inheritance they default to public: struct Address { int street_no; ... char* postal_code; Address (int _street_no, ... , char* _postal_code) : street_no(_street_no), ... postal_code(_postal_code) {} } ... Address temp_address ( /* street_no */, ..., /* postal_code */);

当涉及到初始化结构的方式时，你应该考虑以下方面:

Portability - different compilers, different degree of C++ standard completeness and different C++ standards altogether do limit your options. If you have to work with let's say a C++11 compiler but want to use the C++20 designated aggregate initialization you are out of luck Readability - what is more readable: temp_address.city = "Toronto" or temp_address { ..., "Toronto", ... }? Readability of your code is very important. Especially when you have large structures (worse - nested ones), having unlabeled values all over the place is just asking for trouble Scalability - anything that depends on a specific order is not a good idea. The same goes for lack of labels. You want to move a member up or down the address space of the structure? Good luck with an unlabeled initialization list (hunting down swapped values in structure initialization is a nightmare)... You want to add a new member? Again good luck with anything that depends on a specific order.

虽然点表示法意味着你输入更多，但你从使用它中得到的好处超过了这个问题，因此我建议你使用它，除非你有一个小的结构，它的结构缺乏变化，在这种情况下，你可以使用一个初始化列表。记住:无论何时与他人合作，编写易于遵循的代码都是至关重要的。