aggregate initialization

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

[编辑] 语法

[编辑] 解释

• 数组类型

  Original:

  array type

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• 类类型（通常情况下，struct或union）

  Original:

  class type (typically, struct or union), that has

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 没有私有或受保护的成员

  Original:

  no private or protected members

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• 没有用户提供的构造函数

  Original:

  no user-provided constructors

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• 没有基类

  Original:

  no base classes

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• 没有虚拟成员函​​数

  Original:

  no virtual member functions

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• 没有括号或等于非静态成员的初始化

  Original:

  no brace-or-equal initializers for non-static members

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 为了在类中定义的数组下标/外观，每个数组元素都非静态类成员，是从初始化列表中相应条款的复制初始化.

  Original:

  Each array element or non-static class member, in order of array subscript/appearance in the class definition, is 复制初始化 from the corresponding clause of the initializer list.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 如果初始条款是一个表达式，隐式转换是允许的，除了（C++11 起）如果他们正在缩小（如列表初始化）.

  Original:

  If the initializer clause is an expression, implicit conversions are allowed, except （C++11 起） if they are narrowing (as in 列表初始化).

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 如果初始子句是一个嵌套的支撑初始化列表，相应的类成员本身就是一个总的集合初始化是递归的.

  Original:

  If the initializer clause is a nested braced-init-list, the corresponding class member is itself an aggregate: aggregate initialization is recursive.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 如果���象是一个数组的大小未知，所提供的括号内的初始化列表中有n条款，数组的大小是n

  Original:

  If the object is an array of unknown size, and the supplied brace-enclosed initializer list has n clauses, the size of the array is n

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 期间，跳过集合初始化静态数据成员和匿名位域.

  Original:

  Static data members and anonymous bit-fields are skipped during aggregate initialization.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 如果数的初始值设定项条款的数量超过了成员初始化，该方案是生病形成（编译器错误）

  Original:

  If the number of initializer clauses exceeds the number of members to initialize, the program is ill-formed (compiler error)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 如果数的初始值设定项条款是小于的成员数量，剩余的成员初始化为空列表，执行值初始化。如果一个引用类型的成员是这些剩余的成员之一，该计划是格式错误的（参考值不能初始化）

  Original:

  If the number of initializer clauses is less than the number of members, the remaining members are initialized by empty lists, which performs 值初始化. If a member of a reference type is one of these remaining members, the program is ill-formed (references cannot be value-initialized)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 如果集合初始化使用的形式等号（T a = {args..}），嵌套的大括号初始化列表可能会被忽略掉（略），在这种情况下，许多初始值设定项条款，在必要时用于初始化每名成员或元素所对应的子聚合，并在随后的初始值设定项条款被用来初始化对象的成员。但是，如果该对象没有任何成员（空结构，或只持有静态成员的结构）的一个子集料，括号省略是不允许的，必须使用一个空的嵌套列表{} .

  Original:

  If the aggregate initialization uses the form with the equal sign (T a = {args..}), the braces around the nested initializer lists may be elided (omitted), in which case, as many initializer clauses as necessary are used to initialize every member or element of the corresponding subaggregate, and the subsequent initializer clauses are used to initialize the following members of the object. However, if the object has a sub-aggregate without any members (an empty struct, or a struct holding only static members), brace elision is not allowed, and an empty nested list {} must be used.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• 当工会是第一个非静态数据成员初始化集合初始化，初始化.

  Original:

  When a union is initialized by aggregate initialization, only its first non-static data members is initialized.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[编辑] 注释

[编辑] 为例

#include <string>
#include <array>
struct S {
    int x;
    struct Foo {
        int i;
        int j;
        int a[3];
    } b;
};
 
union U {
    int a;
    const char* b;
};
int main()
{
    S s1 = { 1, { 2, 3, {4, 5, 6} } };
    S s2 = { 1, 2, 3, 4, 5, 6}; // same, but with brace elision
    S s3{1, {2, 3, {4, 5, 6} } }; // same, using direct-list-initialization syntax
//  S s4{1, 2, 3, 4, 5, 6}; // error: brace-elision only allowed with equals sign
 
    int ar[] = {1,2,3}; // ar is int[3]
//  char cr[3] = {'a', 'b', 'c', 'd'}; // too many initializer clauses
    char cr[3] = {'a'}; // array initialized as {'a', '\0', '\0'}
 
    int ar2d1[2][2] = {{1, 2}, {3, 4}}; // fully-braced 2D array: {1, 2}
                                        //                        {3, 4}
    int ar2d2[2][2] = {1, 2, 3, 4}; // brace elision: {1, 2}
                                    //                {3, 4}
    int ar2d3[2][2] = {{1}, {2}};   // only first column: {1, 0}
                                    //                    {2, 0}
 
    std::array<int, 3> std_ar2{ {1,2,3} };    // std::array is an aggregate
    std::array<int, 3> std_ar1 = {1, 2, 3}; // brace-elision okay
 
    int ai[] = { 1, 2.0 }; // narrowing conversion from double to int:
                           // error in C++11, okay in C++03
 
    std::string ars[] = {std::string("one"), // copy-initialization
                         "two",              // conversion, then copy-initialization
                         {'t', 'h', 'r', 'e', 'e'} }; // list-initialization
 
    U u1 = {1}; // OK, first member of the union
//    U u2 = { 0, "asdf" }; // error: too many initializers for union
//    U u3 = { "asdf" }; // error: invalid conversion to int
 
}

[编辑] 另请参阅

• 表初始化