c++ - Evitar la conversión no deseada en el constructor.

c++11 explicit-constructor

Question

Según here , explicit :

Especifica constructores y operadores de conversión (desde C ++ 11) que no permiten conversiones implícitas o inicialización de copia.

Por lo tanto, ¿son estas dos técnicas idénticas?

struct Z {
// ...
Z(long long); // can initialize with a long long
Z(long) = delete; // but not anything smaller
};
struct Z {
// ...
explicit Z(long long); // can initialize ONLY with a long long
};

Answer 1

Ellos no son los mismos.

Del borrador de trabajo estándar n4296 :

12.3.1 - [class.conv.ctor]:
¹ Un constructor declarado sin el especificador de funciones explícito especifica una conversión de los tipos de sus parámetros al tipo de su clase. Tal constructor se llama un constructor de conversión .

² Un constructor explícito construye objetos como constructores no explícitos, pero lo hace solo cuando se usa explícitamente la sintaxis de inicialización directa (8.5) o donde las conversiones (5.2.9, 5.4) se usan explícitamente. Un constructor predeterminado puede ser un constructor explícito; dicho constructor se utilizará para realizar la inicialización predeterminada o la inicialización de valores (8.5).

Seguido de un ejemplo de cada uno respectivamente:

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))
}

Con constructor explícito:

struct Z {
explicit Z();
explicit Z(int);
explicit Z(int, int);
};
Z a; // OK: default-initialization performed
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

Answer 2

No son idénticos.

Z z = 1LL;

Lo anterior funciona con la versión no explícita, pero no con la versión explícita.

La declaración del constructor de Z explícito no impide la conversión del argumento del constructor de otro tipo. Evita la conversión del argumento a Z sin llamar explícitamente al constructor.

A continuación se muestra un ejemplo de llamada explícita de constructor.

Z z = Z(1LL);

Answer 3

No, no son lo mismo. explicit no permite conversiones implícitas a ese tipo si ese constructor está seleccionado, las conversiones implícitas en los argumentos no importan. delete no permite ninguna construcción si ese constructor está seleccionado, y se puede usar para rechazar la conversión implícita de argumentos .

Así, por ejemplo:

struct X {
explicit X(int ) { }
};
void foo(X ) { }
foo(4); // error, because X''s constructor is explicit
foo(X{3}); // ok
foo(X{''3''}); // ok, this conversion is fine

Eso es independiente de delete un constructor:

struct Y {
Y(int ) { }
Y(char ) = delete;
};
void bar(Y ) { }
bar(4); // ok, implicit conversion to Y since this constructor isn''t explicit
bar(''4''); // error, this constructor is deleted
bar(Y{''4''}); // error, doesn''t matter that we''re explicit

Las dos técnicas también son ortogonales. Si desea que un tipo no sea convertible implícitamente y solo se pueda construir desde exactamente un int , puede hacer ambas cosas:

struct W {
explicit W(int ) { }
template <class T>
W(T ) = delete;
};
void quux(W );
quux(4); // error, constructor is explicit
quux(''4''); // error, constructor is deleted
quux(4L); // error, constructor is deleted
quux(W{''4''}); // error, constructor is deleted
quux(W{5}); // ok

Answer 4

bloques explicit conversión implícita a su tipo .

Tu técnica =delete bloquea la conversión implícita de long a long long .

Estos son casi sin relación.

Hay 4 casos que ilustran la diferencia:

Z z = 1L;
Z z = 1LL;

Es una conversión implícita de long y long long a Z

Z z = Z(1L);
Z z = Z(1LL);

Es una conversión explícita de long y long long a Z

Bloques explicit Z(long long) :

Z z = 1L;
Z z = 1LL;

mientras que Z(long)=delete bloques:

Z z = 1L;
Z z = Z(1L);

explicit Z(long long) permite Z z = Z(1L) porque la conversión de long a long long es implícita, pero no está relacionada con la conversión explícita a Z que ocurre después.

Tenga en cuenta que una mezcla de explicit y =delete deja solo Z z=Z(1LL) como válida entre sus 4 versiones.

(Lo anterior supone una copia o movimiento válido ctor; si no, reemplace Z z=Z(...) con Z z(...) y el mismo resultado de las conclusiones).

Answer 5

struct Zb {
Zb(long long)
{}; // can initialize with a long long
Zb(long) = delete; // but not anything smaller
};
struct Za {
// ...
explicit Za(long long)
{}; // can initialize ONLY with a long long
};
int main()
{
Za((long long)10); // works
Za((long)10); // works
Zb((long long)10); // works
Zb((long)10); // does not work
return 0;
}

Tu ejemplo requiere eliminación explícita.

En vivo: http://cpp.sh/4sqb