是否可以在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++中实现的,或者使用这种风格是不好的做法。我喜欢使用这种初始化方式,因为我的结构体很大,而且这种样式可以让我清楚地了解分配给哪个成员的值。

请与我分享是否有其他方法可以达到同样的可读性。

在提出这个问题之前,我已参考以下连结:

C/ c++ for AIX C结构初始化变量 c++中使用标记的静态结构初始化 c++ 11正确的结构初始化


当前回答

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

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

其他回答

这个特性称为指定初始化式。它是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 }
    { }

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

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

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

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

字段标识符实际上是C初始化式语法。在c++中,只需要按正确的顺序给出值,而不需要字段名。不幸的是,这意味着你需要给他们所有(实际上你可以省略后面的零值字段,结果将是相同的):

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

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

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

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