Инициализация списком (начиная с C++11)

Инициализирует объект из списка инициализации в скобках.

Синтаксис

Прямая инициализация списком

Инициализация копированием списка

Инициализация списком выполняется в следующих случаях:

• прямая инициализация списком (рассматриваются как явные, так и неявные конструкторы)

• инициализация копированием списка (рассматриваются как явные, так и неявные конструкторы, но могут вызываться только неявные конструкторы)

Объяснение

Эффекты инициализации списком объекта типа T:

• Если T является агрегированным классом, а список-инициализации-в-фигурных-скобках содержит один элемент того же или производного типа (возможно, cv-квалифицированного), объект инициализируется из этого элемента (с помощью инициализации копированием для инициализации-копированием-списка или прямой инициализации для прямой-инициализации-списком).
• Иначе, если T является массивом символов, а список-инициализации-в-фигурных-скобках содержит единственный элемент, являющийся строковым литералом соответствующего типа, массив инициализируется из строкового литерала, как обычно.

• Иначе, если T является агрегатным типом, выполняется агрегатная инициализация.

• Иначе, если список-инициализации-в-фигурных-скобках пуст и T является типом класса с конструктором по умолчанию, выполняется нициализация значением.

• Иначе, если T является специализацией std::initializer_list, объект T the T инициализируется, как задано здесь.

• Иначе конструкторы T рассматриваются в два этапа:

• Все конструкторы, которые принимают std::initializer_list в качестве единственного аргумента или в качестве первого аргумента, если остальные аргументы имеют значения по умолчанию, проверяются и сопоставляются путём разрешения перегрузки с одним аргументом типа std::initializer_list

• Если предыдущий этап не дает совпадения, все конструкторы T участвуют в разрешении перегрузки для набора аргументов, состоящего из элементов списка-инициализации-в-фигурных скобках, с ограничением, что допустимы только не сужающие преобразования Если на этом этапе создаётся явный конструктор как наилучшее соответствие для инициализации копированием списка, компиляция завершится ошибкой (обратите внимание, что при простой инициализации копированием явные конструкторы вообще не учитываются).

• Иначе (если T не является типом класса), если список-инициализации-в-фигурных скобках имеет только один элемент и либо T не является ссылочным типом, либо ссылочным типом, ссылочный тип которого такой же как или является базовым классом типа элемента, T is инициализируется напрямую (при прямой инициализации списком) or или инициализируется копированием (при инициализации копированием списка), за исключением того, что сужающие преобразования не разрешены.

• Иначе, если T является ссылочным типом, несовместимым с типом элемента:

• Иначе, если список-инициализации-в-фигурных-скобках не содержит элементов, T инициализируется значением.

Инициализация списком std::initializer_list

Объект типа std::initializer_list<E> создаётся из списка инициализаторов, как если бы компилятор сгенерировал и материализовал (начиная с C++17) prvalue типа “массив N const E”, где N количество элементов в списке инициализаторов; это называется резервным массивом списка инициализаторов.

Каждый элемент резервного массива инициализируется копированием соответствующего элемента списка инициализаторов, а объект std::initializer_list<E> создаётся для ссылки на этот массив. Конструктор или функция преобразования, выбранная для копирования, должна быть доступна в контексте списка инициализаторов. Если для инициализации любого из элементов требуется сужающее преобразование, программа некорректна.

Резервный массив имеет такое же время жизни, как и любой другой временный объект, за исключением того, что инициализация объекта std::initializer_list из резервного массива продлевает время жизни массива точно так же, как привязка ссылки к временному объекту.

void f(std::initializer_list<double> il);

void g(float x)
{
   f({1, x, 3});
}

void h()
{
   f({1, 2, 3});
}

struct A { mutable int i; };

void q(std::initializer_list<A>);

void r()
{
    q({A{1}, A{2}, A{3}});
}

// Приведённая выше инициализация будет реализована способом, примерно эквивалентным
// приведенному ниже, при условии, что компилятор может создать объект initializer_list
// с парой указателей, и с учётом того, что `__b` не переживёт вызов `f`.

void g(float x)
{
    const double __a[3] = {double{1}, double{x}, double{3}}; // резервный массив
    f(std::initializer_list<double>(__a, __a + 3));
}

void h()
{
    static constexpr double __b[3] =
        {double{1}, double{2}, double{3}}; // резервный массив
    f(std::initializer_list<double>(__b, __b + 3));
}

void r()
{
    const A __c[3] = {A{1}, A{2}, A{3}}; // резервный массив
    q(std::initializer_list<A>(__c, __c + 3));
}

Все ли резервные массивы различны (то есть хранятся в непересекающихся объектах) не указано:

bool fun(std::initializer_list<int> il1, std::initializer_list<int> il2)
{
    return il2.begin() == il1.begin() + 1;
}

bool overlapping = fun({1, 2, 3}, {2, 3, 4}); // результат не указан: резервные
                                              // массивы могут совместно использовать
                                              // хранилище в пределах {1, 2, 3, 4}

Сужающие преобразования

Инициализация списка ограничивает разрешённые неявные преобразования запрещая следующее:

• преобразование из типа с плавающей запятой в целочисленный тип

• преобразование из целочисленного типа в тип с плавающей запятой, за исключением случаев, когда источником является константное выражение, значение которого может храниться точно в целевом типе

• преобразование из целочисленного типа или типа перечисления с незаданной областью видимости в целочисленный тип, который не может представить все значения оригинала, за исключением случаев, когда источник является константным выражением, значение которого может храниться точно в целевом типе

• • источник представляет собой битовое поле , ширина w которого меньше ширины его типа (или, для типа перечисления, лежащего в основе его типа) и целевой тип может представлять все значения гипотетического расширенного целочисленного типа с шириной w и с тем же знаком, что и исходный тип, или

• • источник это константное выражение, значение которого может храниться точно в целевом типе

• преобразование типа указателя или типа указателя на элемент в bool

Примечание

Каждое предложение инициализатора располагается перед любым предложением инициализатора, которое следует за ним в списке-инициализации-с-фигурными-скобками. Это отличается от аргументов выражения вызова функции, которые не имеют последовательности (до C++17)имеют неопределённую последовательность (начиная с C++17).

Список инициализации в фигурных скобках не является выражением и, следовательно, не имеет типа, например decltype({1,2}) не верно. Отсутствие типа означает, что вывод типа шаблона не может вывести тип, соответствующий списку-инициализации-в-фигурных-скобках, поэтому при объявлении template<class T> void f(T); выражение f({1,2,3}) не верно. Однако в противном случае параметр шаблона можно вывести, как в случае с std::vector<int> v(std::istream_iterator<int>(std::cin), {}), где тип итератора определяется первым аргументом, но также используется во второй позиции параметра. Специальное исключение сделано для вывода типа с использованием ключевого слова auto , которое выводит любой список-инициализации-в-фигурных-скобках как std::initializer_list в инициализации-копированием-списка.

Кроме того, поскольку список-инициализации-в-фигурных-скобках не имеет типа, применяются специальные правила разрешения перегрузки когда он используется в качестве аргумента для вызова перегруженной функции.

Агрегатные копирование/перемещение инициализирются непосредственно из одноэлементного списка-инициализации-в-фигурных-скобках того же типа, но неагрегаты сначала рассматривают конструкторы std::initializer_list:

struct X {}; // агрегат

struct Q     // не агрегат
{
    Q() = default;
    Q(Q const&) = default;
    Q(std::initializer_list<Q>) {}
};

int main()
{
    X x;
    X x2 = X{x}; // конструктор копирования (не агрегатная инициализация)
    
    Q q;
    Q q2 = Q{q}; // конструктор инициализации списком (не конструктор копирования)
}

Некоторые компиляторы (например, gcc 10) в режиме C++20 рассматривают только преобразование указателя или указателя на элемент в сужение bool.

Пример

#include <iostream>
#include <map>
#include <string>
#include <vector>

struct Foo
{
    std::vector<int> mem = {1, 2, 3}; // инициализация списком нестатического элемента
    std::vector<int> mem2;
    
    Foo() : mem2{-1, -2, -3} {} // инициализация элемента списком в конструкторе
};

std::pair<std::string, std::string> f(std::pair<std::string, std::string> p)
{
    return {p.second, p.first}; // инициализация списком в операторе return
}

int main()
{
    int n0{};  // инициализация значением (в ноль)
    int n1{1}; // прямая инициализация списком
    
    std::string s1{'a', 'b', 'c', 'd'}; // вызов конструктора инициализации списком
    std::string s2{s1, 2, 2};           // вызов обычного конструктора
    std::string s3{0x61, 'a'}; // конструктор инициализации списком предпочтительнее
                               // для (int, char)

    int n2 = {1}; // инициализация копированием списка
    double d = double{1.2}; // инициализация списком prvalue, затем инициализация
                            // копированием
    auto s4 = std::string{"ПриветМир"}; // то же, что и выше, временные объекты
                                        // не создаются начиная с C++17
                     
    std::map<int, std::string> m = // инициализация вложенным списком
    {
        {1, "a"},
        {2, {'a', 'b', 'c'}},
        {3, s1}
    };

    std::cout << f({"привет", "мир"}).first // инициализация списком в вызове функции
              << '\n';

    const int (&ar)[2] = {1, 2}; // привязывает ссылку lvalue к временному массиву
    int&& r1 = {1}; // привязывает ссылку rvalue к временному int
//  int& r2 = {2}; // ошибка: невозможно связать rvalue с неконстантной ссылкой lvalue

//  int bad{1.0}; // ошибка: сужающее преобразование
    unsigned char uc1{10}; // ok
//  unsigned char uc2{-1}; // ошибка: сужающее преобразование

    Foo f;

    std::cout << n0 << ' ' << n1 << ' ' << n2 << '\n'
              << s1 << ' ' << s2 << ' ' << s3 << '\n';
    for(auto p: m)
        std::cout << p.first << ' ' << p.second << '\n';
    for(auto n: f.mem)
        std::cout << n << ' ';
    for(auto n: f.mem2)
        std::cout << n << ' ';

    [](...){}(d, ar, r1, uc1); // имеет эффект [[maybe_unused]]
}

мир
0 1 1
abcd cd aa
1 a
2 abc
3 abcd
1 2 3 -1 -2 -3

Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Смотрите также

• конструктор
• конвертирующий конструктор
• присваивание копированием
• конструктор копирования
• пропуск копирования
• конструктор по умолчанию
• explicit
• инициализация
  • агрегатная инициализация
  • константная инициализация
  • инициализация копированием
  • прямая инициализация
  • инициализация ссылкой
  • инициализация значением
  • инициализация нулём
• присваивание перемещением
• конструктор перемещения
• new