它不是在c++中实现的。(同样，char* strings?我希望不会)。

通常情况下，如果你有这么多参数，那就是相当严重的代码味道。但是，为什么不简单地对结构进行值初始化，然后为每个成员赋值呢?

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

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

你有

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.

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

如果你想清楚每个初始化值是什么，只需要把它分成多行，并在每一行上加一个注释:

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

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

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

它不是在c++中实现的。(同样，char* strings?我希望不会)。

通常情况下，如果你有这么多参数，那就是相当严重的代码味道。但是，为什么不简单地对结构进行值初始化，然后为每个成员赋值呢?