受到这个非常简洁的答案的启发:(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-",
  );
}

这样做有一些缺点，主要与未初始化的成员有关。从链接的答案评论说，它编译有效，虽然我没有测试它。

总的来说，我认为这是一个很好的方法。

这个特性称为指定初始化式。它是C99标准的补充。然而，这个特性在c++ 11中被忽略了。根据c++编程语言，第4版，第44.3.3.2节(c++未采用的C特性):

c++故意没有采用C99的一些附加功能(与C89相比): [1]变长数组(VLAs);使用矢量或某种形式的动态数组 [2]指定初始化式;使用构造函数

C99语法有指定的初始化式[参见ISO/IEC 9899:2011, N1570委员会草案- 2011年4月12日]

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没有指定的初始化式[参见ISO/IEC 14882:2011, N3690委员会草案- 2013年5月15日]

8.5初始化

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 }
    { }

为了达到同样的效果，可以使用构造函数或初始化列表:

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

你甚至可以把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);

免责声明:我不推荐这种风格

在我的问题没有得到令人满意的结果之后(因为c++没有为结构实现基于标记的init)，我使用了我在这里找到的技巧:c++结构体的成员默认初始化为0吗?

对你来说，它相当于这样做:

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

这当然是最接近您最初想要的(除那些您想初始化的字段外，所有字段都为零)。