Пространства имён
Варианты
Действия

aggregate initialization

Материал из cppreference.com
< cpp‎ | language

 
 
Язык С++
Общие темы
Управление программой
Операторы условного выполнения
Операторы повторения
Операторы перехода
Функции
объявление функции
объявление лямбда-функции
шаблон функции
спецификатор inline
спецификаторы исключений (устарело)
спецификатор noexcept (C++11)
Исключения
Пространства имён
объявление пространства имён
псевдонимы пространства имён
Типы
спецификатор decltype (C++11)
Спецификаторы
cv-спецификаторы
спецификаторы продолжительности хранения
спецификатор constexpr (C++11)
спецификатор auto (C++11)
спецификатор alignas (C++11)
Инициализация
Литералы
Выражения
Утилиты
Типы
typedef-объявление
объявление псевдонима типа (C++11)
атрибуты (C++11)
Приведения типов
неявные преобразования
const_cast-преобразование
static_cast-преобразование
dynamic_cast-преобразование
reinterpret_cast-преобразование
C-подобное и функциональное приведение типов
Выделение памяти
Классы
Особые свойства классовых функций
Специальные функции-члены
Шаблоны
шаблон класса
шаблон функции
специализация шаблона
упакованные параметры (C++11)
Разное
Ассемблерные вставки
 
Инициализирует совокупного от фигурных-Init-лист
Оригинал:
Initializes an aggregate from braced-init-list
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Содержание

[править] Синтаксис

T object = {arg1, arg2, ...}; (1)
T object {arg1, arg2, ...}; (2) (начиная с C++11)

[править] Объяснение

Совокупный инициализации формы Список инициализации, который инициализирует' агрегатов
Оригинал:
Aggregate initialization is a form of Список инициализации, which initializes aggregates
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Агрегат является объектом типа, что является одним из следующего
Оригинал:
An aggregate is an object of the type that is one of the following
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • тип массива
    Оригинал:
    array type
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Класс типа (как правило, struct или union), что имеет
    Оригинал:
    class type (typically, struct or union), that has
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • нет частных или защищенных членов
    Оригинал:
    no private or protected members
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • не предоставленные пользователем конструкторов
    Оригинал:
    no user-provided constructors
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • нет базовых классов
    Оригинал:
    no base classes
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • нет виртуальных функций-членов
    Оригинал:
    no virtual member functions
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • не скобкой или равно инициализаторы для нестатических членов
    Оригинал:
    no brace-or-equal initializers for non-static members
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Влияние совокупного инициализации являются:
Оригинал:
The effects of aggregate initialization are:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Каждый элемент массива или нестатический член класса, в порядке индекса массива / появление в определении класса, является Копия инициализации из соответствующего пункта из списка инициализации.
    Оригинал:
    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.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если инициализатор предложение является выражением, неявные преобразования допускается, за исключением (начиная с C++11), если они сужаются (как в Список инициализации).
    Оригинал:
    If the initializer clause is an expression, implicit conversions are allowed, except (начиная с C++11) if they are narrowing (as in Список инициализации).
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если инициализатор пунктом является вложенной приготовился-INIT-лист, член-корреспондент класс сам совокупности: совокупность инициализации рекурсивных.
    Оригинал:
    If the initializer clause is a nested braced-init-list, the corresponding class member is itself an aggregate: aggregate initialization is recursive.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если объект является массив неизвестного размера, и поставляется фигурные скобки инициализатор список имеет n положения, размера массива n
    Оригинал:
    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
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Статические данные-члены и анонимные битовые поля пропускаются во время групповой инициализации.
    Оригинал:
    Static data members and anonymous bit-fields are skipped during aggregate initialization.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если количество инициализаторов пунктов превышает количество членов для инициализации, программа плохо сформированных (ошибка компилятора)
    Оригинал:
    If the number of initializer clauses exceeds the number of members to initialize, the program is ill-formed (compiler error)
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если количество инициализаторов пунктов меньше, чем число членов, остальные члены инициализируются пустыми списками, которая выполняет Значение инициализации. Если член ссылочного типа является одним из этих остальных членов, программа плохо сформированных (ссылки не может быть инициализирован значением)
    Оригинал:
    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)
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Если совокупный инициализации используется форма со знаком равенства (T a = {args..}), фигурные скобки вложенные списки инициализации могут быть опущены (опущено), в этом случае, так как многие положения инициализатор по мере необходимости используются для инициализации каждого члена или элемент соответствующего subaggregate, и последующие пункты инициализатор используются для инициализации следующие члены объекта. Однако, если объект имеет суб-агрегата без членов (пустой структуры или структуры холдинга только статические члены), скобки элизии не допускается, и пустой вложенных {} список должен быть использован.
    Оригинал:
    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.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
  • Когда союз инициализируется агрегатную инициализацию, только ее первый не-статических данных инициализируется.
    Оригинал:
    When a union is initialized by aggregate initialization, only its first non-static data members is initialized.
    Текст был переведён автоматически используя Переводчик Google.
    Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

[править] Заметки

До C + +11, сужающие преобразования были разрешены в совокупности инициализации, но они больше не позволили.
Оригинал:
Until C++11, narrowing conversions were permitted in aggregate initialization, but they are no longer allowed.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
До C + +11, совокупный инициализации не может быть использована в списке инициализации конструктора в связи с ограничениями синтаксиса.
Оригинал:
Until C++11, aggregate initialization could not be used in a constructor initializer list due to syntax restrictions.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

[править] Пример

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


[править] См. также