Conversión definida por el usuario de C ++

Habilita la conversión implícita o explícita de un tipo de clase a otro tipo.

Sintaxis

La función de conversión se declara como unastatic función miembro o plantilla de función miembro sin parámetros, sin tipo de retorno explícito y con el nombre del formulario:

1) Declara una función de conversión definida por el usuario que participa en todas las conversiones implícitas y explícitas2) Declara una función de conversión definida por el usuario que participa únicamente en la inicialización directa y en las conversiones explícitas.

ID de tipo de conversión es un identificador de tipo excepto que la función y array operadores [] o () no están permitidos en su declarador (por lo tanto, la conversión a tipos como puntero a array requiere un alias de tipo / typedef o una plantilla de identidad: ver más abajo). Independientemente de typedef, ID de tipo de conversión no puede representar un array o un tipo de función.

Aunque el tipo de retorno no está permitido en la declaración de una función de conversión definida por el usuario, el decl-specifier-seq de la gramática de la declaración puede estar presente y puede incluir cualquier especificador que no sea especificador de tipo o la palabra clave static, En particular, además explicit, los especificadores inline, virtual, constexpr y friend también están permitidos (tenga en cuenta que friend requiere un nombre calificado: friend A::operator B();).

Cuando dicha función miembro se declara en la clase X, realiza la conversión de X a ID de tipo de conversión:

structX//implicit conversionoperatorint()constreturn7;// explicit conversionexplicitoperatorint*()constreturnnullptr;//   Error: array operator not allowed in conversion-type-id//   operator int(*)[3]() const  return nullptr; using arr_t =int[3];operator arr_t*()constreturnnullptr;// OK if done through typedef//  operator arr_t () const; // Error: conversion to array not allowed in any case;intmain()
    X x;int n =static_cast<int>(x);// OK: sets n to 7int m = x;// OK: sets m to 7int* p =static_cast<int*>(x);// OK: sets p to null//  int* q = x; // Error: no implicit conversionint(*pa)[3]= x;// OK

Explicación

La función de conversión definida por el usuario se invoca en la segunda etapa de la conversión implícita, que consiste en cero o un constructor de conversión o cero o una función de conversión definida por el usuario.

Si se pueden usar tanto las funciones de conversión como los constructores de conversión para realizar alguna conversión definida por el usuario, las funciones de conversión y los constructores se consideran por resolución de sobrecarga en contextos de inicialización de copia y de inicialización de referencia, pero solo los constructores se consideran en contextos de inicialización directa .

structToTo()=default;To(conststructFrom&)// converting constructor;structFromoperatorTo()constreturnTo();// conversion function;intmain()
    From f;
    To t1(f);// direct-initialization: calls the constructor// (note, if converting constructor is not available, implicit copy constructor//  will be selected, and conversion function will be called to prepare its argument)
    To t2 = f;// copy-initialization: ambiguous// (note, if conversion function is from a non-const type, e.g.//  From::operator To();, it will be selected instead of the ctor in this case)
    To t3 =static_cast<To>(f);// direct-initialization: calls the constructorconst To& r = f;// reference-initialization: ambiguous

Función de conversión a su propia clase (posiblemente calificada por cv) (o a una referencia a ella), a la base de su propia clase (o una referencia a ella) y al tipo void se puede definir, pero no se puede ejecutar como parte de la secuencia de conversión, excepto, en algunos casos, a través del envío virtual:

structD;structBvirtualoperatorD()=0;;structD:BoperatorD()overridereturnD();;intmain()
    D obj;
    D obj2 = obj;// does not call D::operator D()
    B& br = obj;
    D obj3 = br;// calls D::operator D() through virtual dispatch

También se puede llamar utilizando la sintaxis de llamada de función miembro:

structB;structX:Boperator B&()return*this;;;intmain()
    X x;
    B& b1 = x;// does not call X::operatorB&()
    B& b2 =static_cast<B&>(x);// does not call X::operatorB&
    B& b3 = x.operator B&();// calls X::operatorB&

Al realizar una llamada explícita a la función de conversión, el tipo de identificación es codicioso: es la secuencia más larga posible de tokens que es un tipo de identificación válido (incluyendo attributes, Si alguna):

& x.operatorint* a;// parsed as & (x.operator int*) a// not as & (x.operator int) * a

structXoperatorint();// OKoperatorauto()->short;// error: trailing return type not part of syntaxoperatorauto()constreturn10;// OK: deduced return type;

Las funciones de conversión se pueden heredar y pueden ser virtuales, pero no se pueden static. Una función de conversión en la clase derivada no oculta una función de conversión en la clase base a menos que estén convirtiendo al mismo tipo.

La función de conversión puede ser una función miembro de la plantilla, por ejemplo, std :: auto_ptr:: operador auto_ptr. Consulte la plantilla de miembro y la deducción de argumentos de la plantilla para conocer las reglas especiales aplicables.