15 Special member functions [special]

Конструктор, объявленный без, function-specifier explicit определяет преобразование типов его параметров (если есть) в тип своего класса. Такой конструктор называется converting constructor. [ Example:

struct X {
    X(int);
    X(const char*, int =0);
    X(int, int);
};

void f(X arg) {
  X a = 1;          // a = X(1)
  X b = "Jessie";   // b = X("Jessie",0)
  a = 2;            // a = X(2)
  f(3);             // f(X(3))
  f({1, 2});        // f(X(1,2))
}

 — end example ]

[  Note: Явный конструктор создает объекты так же, как неявные конструкторы, но делает это только там, direct-initialization где явно используются синтаксис или приведение типов ([expr.static.cast], [expr.cast]); см. также [over.match.copy]. Конструктор по умолчанию может быть явным конструктором; такой конструктор будет использоваться для выполнения инициализации по умолчанию или value-initialization. [ Example:

struct Z {
  explicit Z();
  explicit Z(int);
  explicit Z(int, int);
};

Z a;                            // OK: default-initialization performed
Z b{};                          // OK: direct initialization syntax used
Z c = {};                       // error: copy-list-initialization
Z a1 = 1;                       // error: no implicit conversion
Z a3 = Z(1);                    // OK: direct initialization syntax used
Z a2(1);                        // OK: direct initialization syntax used
Z* p = new Z(1);                // OK: direct initialization syntax used
Z a4 = (Z)1;                    // OK: explicit cast used
Z a5 = static_cast<Z>(1);       // OK: explicit cast used
Z a6 = { 3, 4 };                // error: no implicit conversion

 — end example ] ] — end note 

Неявный конструктор копирования / перемещения ([class.copy]) - это конструктор преобразования. [  Note: Неявно объявленный конструктор копирования / перемещения не является явным конструктором; он может вызываться для неявного преобразования типов. ] — end note 

Функция-член класса X без параметров с именем формы

conversion-function-id:
	operator conversion-type-id

conversion-type-id:
	type-specifier-seq conversion-declarator${}_{opt}$

conversion-declarator:
	ptr-operator conversion-declarator${}_{opt}$

указывает преобразование из X в тип, указанный в conversion-type-id. Такие функции называются conversion functions. A decl-specifierв decl-specifier-seq функции преобразования (если есть) не должно быть ни a, defining-type-specifierни static. Тип функции преобразования ([dcl.fct]) - «функция, не возвращающая никаких параметров conversion-type-id». Функция преобразования никогда не используется для преобразования объекта (возможно, квалифицированного cv) в (возможно, квалифицированный cv) объект того же типа (или ссылку на него) в базовый класс (возможно, квалифицированный cv) этого типа (или ссылка на него) или на (возможно cv-квалифицированный) void.117 [ Example:

struct X {
  operator int();
  operator auto() -> short;     // error: trailing return type
};

void f(X a) {
  int i = int(a);
  i = (int)a;
  i = a;
}

Во всех трех случаях присвоенное значение будет преобразовано в X​::​operator int(). ] — end example 

Функция преобразования может быть explicit, и в этом случае она рассматривается только как определяемое пользователем преобразование для direct-initialization. В противном случае пользовательские преобразования не ограничиваются использованием в назначениях и инициализациях. [ Example:

class Y { };
struct Z {
  explicit operator Y() const;
};

void h(Z z) {
  Y y1(z);          // OK: direct-initialization
  Y y2 = z;         // ill-formed: copy-initialization
  Y y3 = (Y)z;      // OK: cast notation
}

void g(X a, X b) {
  int i = (a) ? 1+a : 0;
  int j = (a&&b) ? a+b : i;
  if (a) {
  }
}

 — end example ]

Не conversion-type-id должен представлять тип функции или тип массива. In conversion-type-id a conversion-function-id - это самая длинная последовательность токенов, которая могла бы образовать conversion-type-id. [  Note: Это предотвращает двусмысленность между оператором-декларатором * и его эквивалентами-выражениями. [ Example:

&ac.operator int*i; // syntax error:
                    // parsed as: &(ac.operator int *)i
                    // not as: &(ac.operator int)*i

Это * декларатор указателя, а не оператор умножения. ] Это правило также предотвращает двусмысленность атрибутов. [ — end example  Example:

operator int [[noreturn]] ();   // error: noreturn attribute applied to a type

 — end example ] ] — end note 

Функции преобразования наследуются.

Функции преобразования могут быть виртуальными.

В шаблоне функции преобразования не должно быть файла deduced return type. [ Example:

struct S {
  operator auto() const { return 10; }      // OK
  template<class T>
  operator auto() const { return 1.2; }     // error: conversion function template
};

 — end example ]

Объект типа класса может быть инициализирован заключенным в круглые скобки expression-list, где expression-list конструируется как список аргументов для конструктора, который вызывается для инициализации объекта. В качестве альтернативы, single assignment-expression может быть указан как initializer using = форма инициализации. Применяется либо семантика прямой инициализации, либо семантика копирования-инициализации; см [dcl.init]. [ Example:

struct complex {
  complex();
  complex(double);
  complex(double,double);
};

complex sqrt(complex,complex);

complex a(1);                   // initialize by a call of complex(double)
complex b = a;                  // initialize by a copy of a
complex c = complex(1,2);       // construct complex(1,2) using complex(double,double),
                                // copy/move it into c
complex d = sqrt(b,c);          // call sqrt(complex,complex) and copy/move the result into d
complex e;                      // initialize by a call of complex()
complex f = 3;                  // construct complex(3) using complex(double), copy/move it into f
complex g = { 1, 2 };           // initialize by a call of complex(double, double)

 — end example ] [ не влияет на инициализацию. ] Note: Overloading of the assignment operator — end note 

Объект типа класса также может быть инициализирован файлом braced-init-list. Применяется семантика инициализации списка; видеть [dcl.init] и [dcl.init.list]. [ Example:

complex v[6] = { 1, complex(1,2), complex(), 2 };

Здесь complex​::​complex(double) вызывается для инициализации v[0] и v[3], complex​::​complex(​double, double) вызывается для инициализации v[1], complex​::​complex() вызывается для инициализации v[2], v[4]и v[5]. Другой пример:

struct X {
  int i;
  float f;
  complex c;
} x = { 99, 88.8, 77.7 };

Здесь x.i инициализируется 99, x.f 88,8 и complex​::​complex(double) вызывается для инициализации x.c. ] [ Фигурные скобки можно опустить в любом агрегате, даже если у агрегата есть члены типа класса с определяемыми пользователем преобразованиями типов; см . ] — end example  Note: initializer-list [dcl.init.aggr] — end note 

[  Note: Если T это тип класса без конструктора по умолчанию, любое объявление объекта типа T (или его массива) неправильно сформировано, если не initializer указано явно (см. [class.init] И [dcl.init]). ] — end note 

[ Порядок, в котором инициализируются объекты со статической продолжительностью хранения или хранением потоков, описан в и . ] Note: [basic.start.dynamic] [stmt.dcl] — end note 

В определении конструктора для класса инициализаторы для прямых и виртуальных подобъектов базового класса и нестатических членов данных могут быть указаны с помощью a ctor-initializer, который имеет форму

ctor-initializer:
	: mem-initializer-list

mem-initializer-list:
	mem-initializer ...${}_{opt}$
	mem-initializer-list , mem-initializer ...${}_{opt}$

mem-initializer:
	mem-initializer-id ( expression-list${}_{opt}$ )
	mem-initializer-id braced-init-list

mem-initializer-id:
	class-or-decltype
	identifier

В mem-initializer-idисходном неквалифицированном поиске identifierвыполняется поиск в области действия класса конструктора, и, если он не найден в этой области, выполняется поиск в области, содержащей определение конструктора. [  Note: Если класс конструктора содержит член с тем же именем, что и прямой или виртуальный базовый класс класса, mem-initializer-id именование члена или базового класса, состоящее из одного идентификатора, относится к члену класса. Для mem-initializer-id скрытого базового класса можно указать полное имя. ] Если не названы класс конструктора, нестатический член данных класса конструктора или прямая или виртуальная база этого класса, объект имеет неправильный формат. — end note mem-initializer-idmem-initializer

A mem-initializer-list может инициализировать базовый класс, используя любой, class-or-decltypeкоторый обозначает этот тип базового класса. [ Example:

struct A { A(); };
typedef A global_A;
struct B { };
struct C: public A, public B { C(); };
C::C(): global_A() { }          // mem-initializer for base A

 — end example ]

Если a mem-initializer-id неоднозначно, потому что он обозначает как прямой не виртуальный базовый класс, так и унаследованный виртуальный базовый класс, mem-initializer это неправильно сформировано. [ Example:

struct A { A(); };
struct B: public virtual A { };
struct C: public A, public B { C(); };
C::C(): A() { }                 // ill-formed: which A?

 — end example ]

A ctor-initializer может инициализировать вариантный член класса конструктора. Если a ctor-initializer указывает более одного mem-initializer для одного и того же члена или для одного и того же базового класса, ctor-initializer это неправильно сформировано.

A mem-initializer-listможет делегировать другому конструктору класса конструктора, используя любой, class-or-decltypeкоторый обозначает сам класс конструктора. Если mem-initializer-idобозначает класс конструктора, он должен быть единственным mem-initializer; конструктор - это delegating constructor, а конструктор, выбранный объектом, mem-initializer- это target constructor. Целевой конструктор выбирается по разрешению перегрузки. После возврата целевого конструктора выполняется тело делегирующего конструктора. Если конструктор прямо или косвенно делегирует себе полномочия, программа имеет неправильный формат и диагностика не требуется. [ Example:

struct C {
  C( int ) { }                  // #1: non-delegating constructor
  C(): C(42) { }                // #2: delegates to #1
  C( char c ) : C(42.0) { }     // #3: ill-formed due to recursion with #4
  C( double d ) : C('a') { }    // #4: ill-formed due to recursion with #3
};

 — end example ]

expression-list Или braced-init-list в mem-initializer используются для инициализации назначенного субобъекта (или, в случае делегирования конструктора, полный класс объекта) в соответствии с правилами инициализаций [dcl.init] для прямой инициализации. [ Example:

struct B1 { B1(int); /* ... */ };
struct B2 { B2(int); /* ... */ };
struct D : B1, B2 {
  D(int);
  B1 b;
  const int c;
};

D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4) { /* ... */ }
D d(10);

 — end example ] [  Note: Инициализация, выполняемая каждым из них, mem-initializer представляет собой файл full-expression. Любое выражение в a mem-initializer оценивается как часть полного выражения, выполняющего инициализацию. ] A, где означает, что виртуальный базовый класс игнорируется во время выполнения конструктора любого класса, который не является самым производным классом. — end note mem-initializermem-initializer-id

Временное выражение, привязанное к ссылочному элементу в a, mem-initializer имеет неправильный формат. [ Example:

struct A {
  A() : v(42) { }   // error
  const int& v;
};

 — end example ]

В конструкторе без делегирования, если данный потенциально сконструированный подобъект не обозначен a mem-initializer-id (включая случай, когда его нет, mem-initializer-list потому что у конструктора нет ctor-initializer), тогда

• (9.1)

  если объект является нестатическим членом данных, который имеет default member initializer либо

  • (9.1.1)

    класс конструктора - это union, и никакой другой вариантный член этого союза не обозначен символом mem-initializer-idили

  • (9.1.2)

    класс конструктора не является объединением, и, если предприятие является членом анонимного союза, ни один из членов этого союза не обозначаются mem-initializer-id,

  сущность инициализируется из инициализатора члена по умолчанию, как указано в [dcl.init];

• (9.2)

  в противном случае, если сущность является анонимным объединением или вариантом member ([class.union.anon]), инициализация не выполняется;

• (9.3)

  в противном случае - сущность default-initialized.

[  Note: An abstract class никогда не является наиболее производным классом, поэтому его конструкторы никогда не инициализируют виртуальные базовые классы, поэтому соответствующий класс mem-initializers может быть опущен. ] Попытка инициализировать более одного нестатического элемента данных объединения приводит к неправильному формату программы. [ После того , как вызов конструктора для класса для объекта с автоматической или динамической продолжительностью хранения завершен, если конструктор не был вызван как часть значения инициализации и член не является ни инициализацией , ни присваивается значение во время выполнения из тело конструктора, член имеет неопределенное значение. ] [  — end note  Note: XXcompound-statement — end note  Example:

struct A {
  A();
};

struct B {
  B(int);
};

struct C {
  C() { }               // initializes members as follows:
  A a;                  // OK: calls A​::​A()
  const B b;            // error: B has no default constructor
  int i;                // OK: i has indeterminate value
  int j = 5;            // OK: j has the value 5
};

 — end example ]

Если данный нестатический член данных имеет как инициализатор члена по умолчанию, так и a mem-initializer, выполняется инициализация, указанная в mem-initializer, и инициализатор члена нестатических данных по умолчанию игнорируется. [  Example: Учитывая

struct A {
  int i = /* some integer expression with side effects */ ;
  A(int arg) : i(arg) { }
  // ...
};

A(int) конструктор просто инициализации i со значением arg, и побочных эффектов в iинициализаторе члена по умолчанию «S не будет иметь место. ] — end example 

Временное выражение, привязанное к ссылочному элементу из инициализатора элемента по умолчанию, имеет неправильный формат. [ Example:

struct A {
  A() = default;        // OK
  A(int v) : v(v) { }   // OK
  const int& v = 42;    // OK
};
A a1;                   // error: ill-formed binding of temporary to reference
A a2(1);                // OK, unfortunately

 — end example ]

В конструкторе без делегирования деструктором для каждого потенциально сконструированного подобъекта типа класса является potentially invoked. [  Note: Это положение гарантирует, что деструкторы могут быть вызваны для полностью сконструированных подобъектов в случае возникновения исключения ([except.ctor]). ]  — end note 

В конструкторе без делегирования инициализация выполняется в следующем порядке:

• (13.1)

  Во-первых, и только для конструктора most derived classвиртуальных базовых классов инициализируются в том порядке, в котором они появляются при обходе направленного ациклического графа базовых классов в глубину слева направо, где «слева направо» порядок появления базовых классов в производном классе base-specifier-list.

• (13.2)

  Затем прямые базовые классы инициализируются в порядке объявления, как они появляются в base-specifier-list (независимо от порядка mem-initializers).

• (13.3)

  Затем нестатические элементы данных инициализируются в том порядке, в котором они были объявлены в определении класса (опять же, независимо от порядка mem-initializers).

• (13.4)

  Наконец, compound-statementвыполняется тело конструктора.

[  Note: Порядок объявления необходим, чтобы гарантировать, что базовые и членские подобъекты уничтожаются в порядке, обратном инициализации. ] — end note 

[ Example:

struct V {
  V();
  V(int);
};

struct A : virtual V {
  A();
  A(int);
};

struct B : virtual V {
  B();
  B(int);
};

struct C : A, B, virtual V {
  C();
  C(int);
};

A::A(int i) : V(i) { /* ... */ }
B::B(int i) { /* ... */ }
C::C(int i) { /* ... */ }

V v(1);             // use V(int)
A a(2);             // use V(int)
B b(3);             // use V()
C c(4);             // use V()

 — end example ]

Имена в expression-list или braced-init-list из a mem-initializer оцениваются в области действия конструктора, для которого mem-initializer указан. [ Example:

class X {
  int a;
  int b;
  int i;
  int j;
public:
  const int& r;
  X(int i): r(a), b(i), i(i), j(this->i) { }
};

инициализируется X​::​r для ссылки X​::​a, инициализируется X​::​b значением параметра конструктора i, инициализируется X​::​i значением параметра конструктора iи инициализируется X​::​j значением X​::​i; это происходит каждый раз, когда создается объект класса X . ] [ Поскольку они оцениваются в области видимости конструктора, указатель может использоваться в элементе a для ссылки на инициализируемый объект. ] — end example  Note: mem-initializerthisexpression-listmem-initializer — end note 

Для virtual member functionsстроящегося объекта можно вызывать функции-члены (в том числе ). Точно так же строящийся объект может быть операндом typeid operator или для dynamic_­cast. Однако, если эти операции выполняются в ctor-initializer (или в функции, вызываемой прямо или косвенно из a ctor-initializer) до завершения всех mem-initializers базовых классов for, программа имеет неопределенное поведение. [ Example:

class A {
public:
  A(int);
};

class B : public A {
  int j;
public:
  int f();
  B() : A(f()),     // undefined: calls member function but base A not yet initialized
  j(f()) { }        // well-defined: bases are all initialized
};

class C {
public:
  C(int);
};

class D : public B, C {
  int i;
public:
  D() : C(f()),     // undefined: calls member function but base C not yet initialized
  i(f()) { }        // well-defined: bases are all initialized
};

 — end example ]

[  Note: [class.cdtor] описывает результат вызовов виртуальных функций typeid и dynamic_­casts во время построения для четко определенных случаев; то есть описывает polymorphic behavior строящийся объект. ] — end note 

За mem-initializerкоторым следует многоточие pack expansion , инициализируются базовые классы, указанные в раскрытии пакета в base-specifier-list классе. [ Example:

template<class... Mixins>
class X : public Mixins... {
public:
  X(const Mixins&... mixins) : Mixins(mixins)... { }
};

 — end example ]

Когда конструктор для типа B вызывается для инициализации объекта другого типа D (то есть, когда конструктор был inherited), инициализация продолжается, как если бы конструктор по умолчанию использовался для инициализации D объекта и каждого подобъекта базового класса, от которого был унаследован конструктор. , за исключением того, что B подобъект инициализируется вызовом унаследованного конструктора. Полная инициализация считается одним вызовом функции; в частности, инициализация параметров унаследованного конструктора упорядочивается перед инициализацией любой части D объекта. [ Example:

struct B1 {
  B1(int, ...) { }
};

struct B2 {
  B2(double) { }
};

int get();

struct D1 : B1 {
  using B1::B1;     // inherits B1(int, ...)
  int x;
  int y = get();
};

void test() {
  D1 d(2, 3, 4);    // OK: B1 is initialized by calling B1(2, 3, 4),
                    // then d.x is default-initialized (no initialization is performed),
                    // then d.y is initialized by calling get()
  D1 e;             // error: D1 has a deleted default constructor
}

struct D2 : B2 {
  using B2::B2;
  B1 b;
};

D2 f(1.0);          // error: B1 has a deleted default constructor

struct W { W(int); };
struct X : virtual W { using W::W; X() = delete; };
struct Y : X { using X::X; };
struct Z : Y, virtual W { using Y::Y; };
Z z(0);             // OK: initialization of Y does not invoke default constructor of X

template<class T> struct Log : T {
  using T::T;       // inherits all constructors from class T
  ~Log() { std::clog << "Destroying wrapper" << std::endl; }
};

Шаблон класса Log обертывает любой класс и пересылает все его конструкторы, одновременно записывая сообщение в стандартный журнал всякий раз, когда объект класса Log уничтожается. ] — end example 

Если конструктор был унаследован от нескольких подобъектов базового класса типа B, программа имеет неправильный формат. [ Example:

struct A { A(int); };
struct B : A { using A::A; };

struct C1 : B { using B::B; };
struct C2 : B { using B::B; };

struct D1 : C1, C2 {
  using C1::C1;
  using C2::C2;
};

struct V1 : virtual B { using B::B; };
struct V2 : virtual B { using B::B; };

struct D2 : V1, V2 {
  using V1::V1;
  using V2::V2;
};

D1 d1(0);       // ill-formed: ambiguous
D2 d2(0);       // OK: initializes virtual B base class, which initializes the A base class
                // then initializes the V1 and V2 base classes as if by a defaulted default constructor

struct M { M(); M(int); };
struct N : M { using M::M; };
struct O : M {};
struct P : N, O { using N::N; using O::O; };
P p(0);             // OK: use M(0) to initialize N's base class,
                    // use M() to initialize O's base class

 — end example ]

Когда объект инициализируется унаследованным конструктором, инициализация объекта завершается, когда завершается инициализация всех подобъектов.

Конструктор без шаблона для класса X является ,copy constructor если ее первый параметр имеет тип X&, const X&, volatile X& или const volatile X&, и либо нет других параметров или также все другие параметры default arguments. [  Example: X​::​X(const X&) и X​::​X(X&,int=1) являются конструкторами копирования.

struct X {
  X(int);
  X(const X&, int = 1);
};
X a(1);             // calls X(int);
X b(a, 0);          // calls X(const X&, int);
X c = b;            // calls X(const X&, int);

 — end example ]

Конструктор без шаблона для класса X является , move constructor если ее первый параметр имеет тип X&&, const X&&, volatile X&&или const volatile X&&, и либо нет других параметров или также все другие параметры default arguments. [  Example: Y​::​Y(Y&&) - конструктор перемещения.

struct Y {
  Y(const Y&);
  Y(Y&&);
};
extern Y f(int);
Y d(f(1));          // calls Y(Y&&)
Y e = d;            // calls Y(const Y&)

 — end example ]

[  Note: Все формы конструктора копирования / перемещения могут быть объявлены для класса. [ Example:

struct X {
  X(const X&);
  X(X&);            // OK
  X(X&&);
  X(const X&&);     // OK, but possibly not sensible
};

 — end example ] ] — end note 

[  Note: Если класс X имеет только конструктор копирования с параметром типа X&, инициализатор типа const X или volatile X не может инициализировать объект типа (возможно, с квалификацией cv) X. [ Example:

struct X {
  X();              // default constructor
  X(X&);            // copy constructor with a non-const parameter
};
const X cx;
X x = cx;           // error: X​::​X(X&) cannot copy cx into x

 — end example ] ] — end note 

Объявление конструктора для класса X неправильно сформировано, если его первый параметр имеет тип (необязательно cv-квалифицированный) X и либо нет других параметров, либо все другие параметры имеют аргументы по умолчанию. Шаблон функции-члена никогда не создается для создания такой сигнатуры конструктора. [ Example:

struct S {
  template<typename T> S(T);
  S();
};

S g;

void h() {
  S a(g);           // does not instantiate the member template to produce S​::​S<S>(S);
                    // uses the implicitly declared copy constructor
}

 — end example ]

Если в определении класса явно не объявляется конструктор копирования, объявляется неявный конструктор implicitly. Если в определении класса объявляется конструктор перемещения или оператор присваивания перемещения, неявно объявленный конструктор копирования определяется как удаленный; в противном случае он определяется как defaulted. Последний случай считается устаревшим, если в классе есть объявленный пользователем оператор присваивания копии или объявленный пользователем деструктор.

Неявно объявленный конструктор копирования для класса X будет иметь форму

X::X(const X&)

если каждый потенциально сконструированный подобъект типа класса M (или его массива) имеет конструктор копирования, первый параметр которого имеет тип const M& или const volatile M&.119 В противном случае неявно объявленный конструктор копии будет иметь вид

X::X(X&)

Если в определении класса X явно не объявляется конструктор перемещения, неявный конструктор будет неявно объявлен как заданный по умолчанию тогда и только тогда, когда

• (8.1)

  X не имеет объявленного пользователем конструктора копирования,

• (8.2)

  X не имеет объявленного пользователем оператора присваивания копии,

• (8.3)

  X не имеет объявленного пользователем оператора присваивания перемещения, и

• (8.4)

  X не имеет деструктора, объявленного пользователем.

[  Note: Когда конструктор перемещения не объявляется неявно или не предоставляется явно, выражения, которые в противном случае вызвали бы конструктор перемещения, могут вместо этого вызывать конструктор копирования. ]  — end note 

Неявно объявленный конструктор перемещения для класса X будет иметь вид

X::X(X&&)

Неявно объявленный конструктор копирования / перемещения является inline public членом своего класса. Конструктор копирования / перемещения по умолчанию для класса X определяется так, как deleted если бы он X имел:

• (10.1)

  вариантный член с нетривиальным соответствующим конструктором и X является классом, подобным объединению,

• (10.2)

  потенциально сконструированный тип подобъекта M (или его массив), который не может быть скопирован / перемещен, поскольку overload resolutionв применении к Mсоответствующему конструктору find приводит к неоднозначности или к функции, которая удаляется или недоступна из конструктора по умолчанию,

• (10.3)

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

• (10.4)

  для конструктора копирования - нестатический член данных ссылочного типа rvalue.

Конструктор перемещения по умолчанию, который определен как удаленный, игнорируется разрешением перегрузки ([over.match], [over.over]). [  Note: В противном случае удаленный конструктор перемещения помешал бы инициализации из rvalue, который вместо этого может использовать конструктор копирования. ] — end note 

Конструктор копирования / перемещения для класса X является тривиальным, если он не предоставляется пользователем и если:

• (11.1)

  класс X не имеет virtual functions и нет virtual base classes, и

• (11.2)

  конструктор, выбранный для копирования / перемещения каждого прямого подобъекта базового класса, является тривиальным, и

• (11.3)

  для каждого нестатического члена данных, X который относится к типу класса (или его массиву), конструктор, выбранный для копирования / перемещения этого члена, является тривиальным;

в противном случае - конструктор копирования / перемещения non-trivial.

Конструктор копирования / перемещения, который установлен по умолчанию и не определен как удаленный, - implicitly defined это если он есть odr-used или когда он явно задан по умолчанию после его первого объявления. [  Note: Конструктор копирования / перемещения определяется неявно, даже если реализация опускает его odr-use ([class.temporary]). ] Если неявно определенный конструктор удовлетворяет требованиям a , то неявно определенный конструктор будет . — end note constexpr constructor constexpr

Прежде чем конструктор копирования / перемещения по умолчанию для класса будет неявно определен, все не предоставленные пользователем конструкторы копирования / перемещения для его потенциально созданных подобъектов должны быть неявно определены. [  Note: Неявно объявленный конструктор копирования / перемещения имеет подразумеваемый exception specification. ] — end note 

Неявно определенный конструктор копирования / перемещения для класса, неX являющегося объединением, выполняет поэлементное копирование / перемещение его баз и членов. [  Note: Инициализаторы нестатических элементов данных по умолчанию игнорируются. См. Также пример в [class.base.init]. ] Порядок инициализации такой же, как порядок инициализации баз и членов в определяемом пользователем конструкторе (см. ). Пусть будет либо параметром конструктора, либо, для конструктора перемещения, значением xvalue, относящимся к параметру. Каждый базовый или нестатический член данных копируется / перемещается в соответствии с его типом:  — end note  [class.base.init] x

• (14.1)

  если член является массивом, каждый элемент напрямую инициализируется соответствующим подобъектом x;

• (14.2)

  если член m имеет ссылочный тип rvalue T&&, он инициализируется напрямую с помощью static_­cast<T&&>(x.m);

• (14.3)

  в противном случае база или член инициализируются напрямую соответствующей базой или членом x.

Подобъекты виртуального базового класса должны быть инициализированы только один раз неявно определенным конструктором копирования / перемещения (см [class.base.init]. Раздел "Ресурсы" ).

Неявно определенный конструктор копирования / перемещения для союзной X копирует object representation из X.

Пользователь объявленной copy оператор присваивания X​::​operator= не является членом статической функцией не-шаблона класса X ровно с одним параметром типа X, X&, const X&, volatile X& или const volatile X&.120 [  Note: Должен быть объявлен перегруженный оператор присваивания, имеющий только один параметр; см [over.ass]. ] [ Для класса может быть объявлено более одной формы оператора присваивания копии. ] [ Если у класса есть только оператор присваивания копии с параметром типа , выражение типа const не может быть присвоено объекту типа . [ — end note  Note:  — end note  Note: XX&XX Example:

struct X {
  X();
  X& operator=(X&);
};
const X cx;
X x;
void f() {
  x = cx;           // error: X​::​operator=(X&) cannot assign cx into x
}

 — end example ] ] — end note 

Если в определении класса явно не объявляется оператор присваивания копии, он объявляется implicitly. Если определение класса объявляет конструктор перемещения или оператор присваивания перемещения, неявно объявленный оператор присваивания копии определяется как удаленный; в противном случае он определяется как defaulted. Последний случай считается устаревшим, если в классе есть объявленный пользователем конструктор копии или объявленный пользователем деструктор. Неявно объявленный оператор присваивания копии для класса X будет иметь вид

X& X::operator=(const X&)

если

• (2.1)

  каждый непосредственный базовый класс B из X имеет оператор присваивания , копирование параметры которого имеет типа const B&, const volatile B& или B, и

• (2.2)

  для всех нестатических членов данных, X которые относятся к типу класса M (или его массиву), каждый такой тип класса имеет оператор присваивания копии, параметр которого имеет тип const M&, const volatile M& или M.121

В противном случае неявно объявленный оператор присваивания копии будет иметь вид

X& X::operator=(X&)

Пользователь объявленной move оператор присваивания X​::​operator= не является членом статической функцией не-шаблона класса X ровно с одним параметром типа X&&, const X&&, volatile X&&, или const volatile X&&. [  Note: Должен быть объявлен перегруженный оператор присваивания, имеющий только один параметр; см [over.ass]. ] [ Для класса может быть объявлено более одной формы оператора присваивания перемещения. ]  — end note  Note:  — end note 

Если в определении класса X явно не объявляется оператор присваивания перемещения, он будет неявно объявлен как принятый по умолчанию тогда и только тогда, когда

• (4.1)

  X не имеет объявленного пользователем конструктора копирования,

• (4.2)

  X не имеет конструктора перемещения, объявленного пользователем,

• (4.3)

  X не имеет объявленного пользователем оператора присваивания копии, и

• (4.4)

  X не имеет деструктора, объявленного пользователем.

[  Example: Определение класса

struct S {
  int a;
  S& operator=(const S&) = default;
};

не будет неявно объявлен оператор присваивания по умолчанию, поскольку оператор присваивания копии был объявлен пользователем. Оператор присваивания перемещения может быть явно задан по умолчанию.

struct S {
  int a;
  S& operator=(const S&) = default;
  S& operator=(S&&) = default;
};

 — end example ]

Неявно объявленный оператор присваивания перемещения для класса X будет иметь вид

X& X::operator=(X&&);

Неявно объявленный оператор присваивания копирования / перемещения для класса X имеет тип возвращаемого значения X&; он возвращает объект, для которого вызывается оператор присваивания, то есть объект, которому назначен. Неявно объявленный оператор присваивания копирования / перемещения является inline public членом своего класса.

Оператор присваивания копирования / перемещения по умолчанию для класса X определяется как удаленный, если X он:

• (7.1)

  вариантный член с нетривиальным соответствующим оператором присваивания и X является классом, подобным объединению, или

• (7.2)

  нестатический член данных const неклассового типа (или его массив), или

• (7.3)

  нестатический член данных ссылочного типа, или

• (7.4)

  прямой нестатический член данных типа класса M (или его массива) или прямой базовый класс, M который не может быть скопирован / перемещен, поскольку overload resolutionв применении к Mсоответствующему оператору присваивания find приводит к неоднозначности или к функции, которая удаляется или недоступна из оператора присваивания по умолчанию.

Оператор присваивания перемещения по умолчанию, который определен как удаленный, игнорируется разрешением перегрузки ([over.match], [over.over]).

Поскольку оператор присваивания копирования / перемещения неявно объявляется для класса, если он не объявлен пользователем, оператор присваивания копирования / перемещения базового класса всегда скрывается соответствующим оператором присваивания производного класса ([over.ass]). A, using-declarationкоторый переносит из базового класса оператор присваивания с типом параметра, который может быть типом оператора присваивания копирования / перемещения для производного класса, не считается явным объявлением такого оператора и не подавляет неявное объявление производного оператор класса; оператор, представленный с помощью using-declaration , скрыт неявно объявленным оператором в производном классе.

Оператор присваивания копирования / перемещения для класса X является тривиальным, если он не предоставляется пользователем и если:

• (9.1)

  класс X не имеет virtual functions и нет virtual base classes, и

• (9.2)

  оператор присваивания, выбранный для копирования / перемещения каждого прямого подобъекта базового класса, является тривиальным, и

• (9.3)

  для каждого нестатического элемента данных X , принадлежащего к типу класса (или его массиву), оператор присваивания, выбранный для копирования / перемещения этого члена, является тривиальным;

в противном случае используется оператор присваивания копирования / перемещения non-trivial.

Оператор присваивания копирования / перемещения для класса, X который установлен по умолчанию и не определен как удаленный, - implicitly defined это когда он есть odr-used (например, когда он выбран разрешением перегрузки для назначения объекту своего типа класса) или когда он явно используется по умолчанию после его первого декларация. Неявно определенный оператор присваивания копирования / перемещения - это constexpr если

• (10.1)

  X это буквальный тип, а

• (10.2)

  оператор присваивания, выбранный для копирования / перемещения каждого прямого подобъекта базового класса, является функцией constexpr, и

• (10.3)

  для каждого нестатического члена данных, X имеющего тип класса (или его массив), оператор присваивания, выбранный для копирования / перемещения этого члена, является функцией constexpr.

Перед тем как оператор присваивания копирования / перемещения по умолчанию для класса будет неявно определен, все операторы присваивания копирования / перемещения, не предоставляемые пользователем, для его прямых базовых классов и его нестатических элементов данных должны быть неявно определены. [  Note: Неявно объявленный оператор присваивания копирования / перемещения имеет подразумеваемый exception specification. ] — end note 

Неявно определенный оператор присваивания копирования / перемещения для класса, не являющегося объединением, X выполняет поэлементное присвоение его подобъектов копированию / перемещению. Первыми X назначаются прямые базовые классы в порядке их объявления в base-specifier-list, а затемX назначаются непосредственные нестатические члены данных в том порядке, в котором они были объявлены в определении класса. Пусть x будет либо параметром функции, либо, для оператора перемещения, значением x, относящимся к параметру. Каждому подобъекту присваивается способ, соответствующий его типу:

• (12.1)

  если подобъект имеет тип класса, как если бы при вызове operator= с подобъектом в качестве выражения объекта и соответствующим подобъектом x в качестве единственного аргумента функции (как если бы посредством явной квалификации; то есть игнорирование любых возможных виртуальных замещающих функций в более производных классы);

• (12.2)

  если подобъект является массивом, каждому элементу присваивается способ, соответствующий типу элемента;

• (12.3)

  если подобъект скалярного типа, используется встроенный оператор присваивания.

Не указано, назначаются ли подобъекты, представляющие виртуальные базовые классы, более одного раза неявно определенным оператором присваивания копирования / перемещения. [ Example:

struct V { };
struct A : virtual V { };
struct B : virtual V { };
struct C : B, A { };

Не указано,V назначается ли подобъект виртуального базового класса дважды неявно определенным оператором присваивания копирования / перемещения для C. ] — end example 

Неявно определенный оператор копирующего присваивания для союзной X копирует object representation из X.

При соблюдении определенных критериев реализации разрешается опускать конструкцию копирования / перемещения объекта класса, даже если конструктор, выбранный для операции копирования / перемещения, и / или деструктор для объекта имеют побочные эффекты. В таких случаях реализация рассматривает источник и цель пропущенной операции копирования / перемещения как просто два разных способа ссылки на один и тот же объект. Если первым параметром выбранного конструктора является ссылка rvalue на тип объекта, уничтожение этого объекта происходит тогда, когда цель была бы уничтожена; в противном случае разрушение происходит в более позднее время, когда два объекта были бы уничтожены без оптимизации.122 Это вызванное исключение операций копирования / перемещения разрешено в следующих случаях (которые могут быть объединены для исключения нескольких копий):copy elision

• (1.1)

  в return операторе функции с типом возвращаемого класса, когда expressionэто имя энергонезависимого автоматического объекта (кроме параметра функции или переменной, введенной с помощью exception-declarationa handler([except.handle])) с тем же типом (игнорируя cv-квалификацию ) в качестве возвращаемого типа функции, операцию копирования / перемещения можно опустить, сконструировав автоматический объект непосредственно в возвращаемом объекте вызова функции.

• (1.2)

  в a throw-expression, когда операнд является именем энергонезависимого автоматического объекта (кроме функции или параметра catch-clause), область действия которого не выходит за пределы самого внутреннего охватывающего объекта try-block(если он есть), копирование / перемещение Операция от операнда до exception object может быть опущена путем создания автоматического объекта непосредственно в объекте исключения

• (1.3)

  когда exception-declarationобработчик исключения (Clause [except]) объявляет объект того же типа (за исключением cv-qualification), что и объект exception object, операция копирования может быть опущена, рассматривая exception-declarationкак псевдоним для объекта исключения, если значение программы будет без изменений, за исключением выполнения конструкторов и деструкторов для объекта, объявленного классом exception-declaration. [  Note: Не может быть перехода от объекта исключения, потому что это всегда lvalue. ]  — end note 

Копирование требуется, когда выражение оценивается в контексте, требующем a constant expression и in constant initialization. [  Note: Копирование может не выполняться, если то же выражение оценивается в другом контексте. ] — end note 

[ Example:

class Thing {
public:
  Thing();
  ~Thing();
  Thing(const Thing&);
};

Thing f() {
  Thing t;
  return t;
}

Thing t2 = f();

struct A {
  void *p;
  constexpr A(): p(this) {}
};

constexpr A g() {
  A a;
  return a;
}

constexpr A a;          // well-formed, a.p points to a
constexpr A b = g();    // well-formed, b.p points to b

void g() {
  A c = g();            // well-formed, c.p may point to c or to an ephemeral temporary
}

Здесь критерии исключения могут исключить копирование локального автоматического объекта t в объект результата для вызова функции f(), который является глобальным объектом t2. Фактически создание локального объекта t можно рассматривать как прямую инициализацию глобального объекта t2, и уничтожение этого объекта произойдет при выходе из программы. Добавление конструктора перемещения в Thing имеет тот же эффект, но t2 исключается именно конструкция перемещения от локального автоматического объекта к нему. ] — end example 

В следующих контекстах инициализации копирования вместо операции копирования может использоваться операция перемещения:

• (3.1)

  Если expressionin a return statement - это (возможно id-expression , заключенное в скобки), которое именует объект с автоматической продолжительностью хранения, объявленной в теле или parameter-declaration-clauseсамой внутренней включающей функции, или lambda-expression, или

• (3.2)

  если операнд a throw-expression является именем энергонезависимого автоматического объекта (кроме функции или параметра catch-clause), область действия которого не выходит за пределы самого внутреннего охватывающего объекта try-block(если он есть),

разрешение перегрузки для выбора конструктора для копии сначала выполняется, как если бы объект был обозначен rvalue. Если первое разрешение перегрузки завершилось неудачно или не было выполнено, или если тип первого параметра выбранного конструктора не является ссылкой rvalue на тип объекта (возможно, с квалификацией cv), разрешение перегрузки выполняется снова, рассматривая объект как lvalue. [  Note: Это двухэтапное разрешение перегрузки должно выполняться независимо от того, произойдет ли исключение копирования. Он определяет конструктор, который будет вызываться, если исключение не выполнено, и выбранный конструктор должен быть доступен, даже если вызов отклонен. ] — end note 

[ Example:

class Thing {
public:
  Thing();
  ~Thing();
  Thing(Thing&&);
private:
  Thing(const Thing&);
};

Thing f(bool b) {
  Thing t;
  if (b)
    throw t;            // OK: Thing(Thing&&) used (or elided) to throw t
  return t;             // OK: Thing(Thing&&) used (or elided) to return t
}

Thing t2 = f(false);    // OK: no extra copy/move performed, t2 constructed by call to f

struct Weird {
  Weird();
  Weird(Weird&);
};

Weird g() {
  Weird w;
  return w;             // OK: first overload resolution fails, second overload resolution selects Weird(Weird&)
}

 — end example ]