Существует ли различие между инициализацией копии и прямой инициализацией?

Обновление C ++ 17

В C ++ 17 значение A_factory_func () изменилось с создания временного объекта (C ++ <= 14) на просто указание инициализации любого объекта, которым инициализируется это выражение (грубо говоря) в C ++ 17. Эти объекты (называемые «объектами результатов») представляют собой переменные, созданные объявлением (например, a1 ), искусственные объекты, созданные, когда инициализация завершается, и отбрасываются, или если объект необходим для привязки ссылки (например, в A_factory_func (); . В последнем случае объект создается искусственно, что называется «временной материализацией», потому что A_factory_func () не имеет переменной или ссылки, которые в противном случае требуют существования объекта).

В качестве примеров в нашем случае в случае a1 и a2 специальные правила говорят, что в таких объявлениях объект результата инициализатора prvalue того же типа, что и a1 , является переменной ] a1 , и поэтому A_factory_func () напрямую инициализирует объект a1 . Любое промежуточное приведение в функциональном стиле не будет иметь никакого эффекта, потому что A_factory_func (another-prvalue) просто «проходит через» объект результата внешнего prvalue, чтобы быть также объектом результата внутреннего prvalue.

A a1 = A_factory_func();
A a2(A_factory_func());

] Зависит от того, какой тип A_factory_func () возвращает. Я предполагаю, что он возвращает A - тогда он делает то же самое - за исключением того, что если конструктор копирования явный, тогда первый не будет работать. Прочтите 8.6 / 14

double b1 = 0.5;
double b2(0.5);

Это то же самое, потому что это ' sa встроенный тип (здесь это означает не тип класса). Прочтите 8.6 / 14 .

A c1;
A c2 = A();
A c3(A());

Это не то же самое. Первая инициализируется по умолчанию, если A не является POD, и не выполняет никакой инициализации для POD (см. 8.6 / 9 ). Вторая копия инициализируется: Значение инициализирует временное, а затем копирует это значение в c2 (Прочтите 5.2.3 / 2 и 8.6 / 14 ). Это, конечно, потребует неявного конструктора копирования (прочтите 8.6 / 14 и 12.3.1 / 3 и 13.3.1.3/1 ). Третий создает объявление функции для функции c3 , которая возвращает A и принимает указатель функции на функцию, возвращающую A (Прочтите 8.2 ).

Углубление в процесс инициализации Прямая и копирующая инициализация

Хотя они выглядят одинаково и должны делать то же самое, в некоторых случаях эти две формы заметно отличаются. Две формы инициализации - прямая и инициализация копирования:

T t(x);
T t = x;

Существует поведение, которое мы можем приписать каждой из них:

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

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

Я очень старался и получил следующий код для вывода разного текста для каждой из этих форм , без использования конструкторов от «очевидного» до явного .

#include <iostream>
struct B;
struct A { 
  operator B();
};

struct B { 
  B() { }
  B(A const&) { std::cout << "<direct> "; }
};

A::operator B() { std::cout << "<copy> "; return B(); }

int main() { 
  A a;
  B b1(a);  // 1)
  B b2 = a; // 2)
}
// output: <direct> <copy>

Как это работает. , и почему он выдает такой результат?

1. Прямая инициализация

   Сначала не Я ничего не знаю о конверсии. Он просто попытается вызвать конструктор. В этом случае доступен следующий конструктор, который точно соответствует :

    B (A const &)
   

   Для вызова этого конструктора не требуется никакого преобразования, не говоря уже о пользовательском преобразовании (обратите внимание, что здесь также не происходит преобразования с квалификацией const). И так будет называть это прямой инициализацией.

2. Инициализация копирования

   Как сказано выше, инициализация копирования будет создавать последовательность преобразования, когда a не имеет типа B или не является производным от него (что явно имеет место в данном случае). Таким образом, он будет искать способы выполнить преобразование и найдет следующих кандидатов

    B (A const &)
   оператор B (A &);
   

   Обратите внимание, как я переписал функцию преобразования: Тип параметра отражает тип указателя this , который в неконстантной функции-члене является неконстантным. Теперь мы вызываем этих кандидатов с аргументом x . Выигрывает функция преобразования: потому что, если у нас есть две функции-кандидаты, обе принимающие ссылку на один и тот же тип, то выигрывает версия less const (это, кстати, также механизм, который предпочитает не- Функция-член const вызывает неконстантные объекты).

   Обратите внимание, что если мы изменим функцию преобразования на функцию-член const, тогда преобразование будет неоднозначным (поскольку оба имеют тип параметра A const & then): компилятор Comeau отклоняет его правильно, но GCC принимает это в непедантичном режиме. Однако переключение на -педантический заставляет выводить и соответствующее предупреждение о двусмысленности.

Я надеюсь, что это немного поможет прояснить, чем отличаются эти две формы!