The C++20 standard provides new ways to initialize aggregates. These are:<\/p>\n
T object = { .designator = arg1 , .designator { arg2 } ... };\r\nT object { .designator = arg1 , .designator { arg2 } ... };<\/pre>\n<\/li>\nT object (arg1, arg2, ...);<\/pre>\n<\/li>\n<\/ul>\nIn this article, we will see how list initialization with designated initializers work.<\/p>\n
<\/p>\n
The designated initialization syntax allows to initialize non-static direct data members of a type T. Here is an example: <\/p>\n
struct foo { int a; char c = 'a'; }\r\nfoo f { .a = 42 };<\/pre>\nThe class foo<\/tt> has two non-static data members, a<\/tt> and c<\/tt>. When initializing the object f<\/tt>, the member a<\/tt> is initialized with the syntax .a = 42<\/tt>. In this context, .a<\/tt> is called a designator<\/strong>.<\/p>\n
The following rules apply to designated initializers:<\/p>\n
\n
- a designator must refer to a non-static direct data member<\/li>\n
- all the designator used in the initialization expression must follow the order of the declaration of the data members in the class<\/li>\n
- not all data members must have a designator, but those that do must follow the rule above<\/li>\n
- it is not possible to mix designated and non-designated initialization<\/li>\n
- desginators of the same data member cannot appear multiple times<\/li>\n
- designators cannot be nested<\/li>\n<\/ul>\n
Let us see several examples to understand it better. Consider the following classes:<\/p>\n
struct bar\r\n{\r\n int x;\r\n};\r\n\r\nstruct foo\r\n{\r\n int a;\r\n bar b;\r\n char c = 'a';\r\n double d;\r\n};<\/pre>\nThe following inialization is allowed:<\/p>\n
foo f1{}; \/\/ OK: a = 0, b = {x = 0}, c = 'a', d = 0.0\r\nfoo f2{ .a = 42 }; \/\/ OK: a = 42, b = {x = 0}, c = 'a', d = 0.0\r\nfoo f3{ .a = 42, .c = 'b' }; \/\/ OK: a = 42, b = {x = 0}, c = 'b', d = 0.0\r\nfoo f4{ .a = 42, .b = {.x = 5} }; \/\/ OK: a = 42, b = {x = 5}, c = 'a', d = 0.0\r\nfoo f5{ .a = 42, .b = {5} }; \/\/ OK: a = 42, b = {x = 5}, c = 'a', d = 0.0<\/pre>\nHowever, the following forms of initialization are illegal:<\/p>\n
foo f6{ .d = 1, .a = 42 }; \/\/ ERROR: out-of-order\r\nfoo f7{ .a = 42, true, 'b', 1 }; \/\/ ERROR: mixed designated and non-designated\r\nfoo f8{ .a = 42, .a = 0 }; \/\/ ERROR: duplicate designator \r\nfoo f9{ .b.x = 42 }; \/\/ ERROR: nested initializer\r\nint arr[5] = { [0] = 42 }; \/\/ ERROR: array designators not allowed<\/pre>\nHere are several more examples. Consider the following classes and functions:<\/p>\n
struct A { int a, b; };\r\nstruct B { int b, a; };\r\nstruct C { int a, c; };\r\n\r\nvoid f(A){}\r\nvoid f(B){}\r\nvoid f(C){}\r\nvoid g(B){}<\/pre>\nThe following calls are permitted:<\/p>\n
f({ .a = 1, .c = 2 }); \/\/ OK: calls f(C)\r\ng({ .b = 1, .a = 2 }); \/\/ OK: calls g(B)<\/pre>\nHowever, the following calls are, on the other hand, erroneous:<\/p>\n
f({.a = 1, .b = 2}); \/\/ ERROR: ambiguous between f(A) and f(B)\r\nf({.a = 1}); \/\/ ERROR: ambiguous call, f(A), f(B), or f(C)\r\ng({.a = 1, .b = 2}); \/\/ ERROR: g(B) but designators are in the wrong order<\/pre>\nA designated initializer, and only one, can be used to initialize a union. Let us consider the following union type:<\/p>\n
union Foo\r\n{\r\n int a;\r\n bool b;\r\n char c;\r\n double d;\r\n};<\/pre>\nThe following forms of initialization are correct:<\/p>\n
Foo u1{}; \/\/ OK: a = 0\r\nFoo u2{ .a = 1 }; \/\/ OK: a = 1\r\nFoo u3{ .c = 'b' }; \/\/ OK: c = 'b'<\/pre>\nHowever, having more than one designator is not allowed:<\/p>\n
Foo u4{ .a = 1, .b = true }; \/\/ ERROR: cannot have more than one element<\/pre>\nDesignated initialization is a feature that is also available in the C programming language. However, it is more relaxed than in C++. In C, it is possible to perform out-of-order designated initialization, to mix designated initializers and regular initializers, to nest designators, and to initialize arrays with designators. Therefore, in this aspect, C and C++ are not fully compatible.<\/p>\n
Designated initializers are supported in VC++ 2019 169.1, GCC 8 and Clang 10.<\/p>\n","protected":false},"excerpt":{"rendered":"
The C++20 standard provides new ways to initialize aggregates. These are:<\/p>\n
\n
- list initialization with designated initializers, that has the following forms:\n
T object = { .designator = arg1 , .designator { arg2 } ... };\r\nT object { .designator = arg1 , .designator { arg2 } ... };<\/pre>\n<\/li>\n- direct initialization, that has the following form:\n
T object (arg1, arg2, ...);<\/pre>\n<\/li>\n<\/ul>\nIn this article, we will see how list initialization with designated initializers work.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[1],"tags":[451,543,512],"class_list":["post-3724","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-c","tag-c20","tag-initialization"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t