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 ]