Espacios de nombres
Variantes
Acciones

Especificador explicit

De cppreference.com
< cpp‎ | language
 
 
 
 
explicit (1)
explicit ( expresión ) (2) (desde C++20)
expresión - Una expresión constante convertida contextualmente de tipo bool
1) Especifica que un constructor o función de conversión (desde C++11) o guía de deducción (desde C++17) es explícito(a), es decir, no se puede usar para conversiones implícitas e inicialización de copia.
2) El especificador explicit se puede usar con una expresión constante. La función es explícita si y solo si esa expresión constante se evalúa a true.
(desde C++20)

El especificador explicit puede aparecer solamente dentro de la sec-decl-especificadores de la declaración de un constructor o función de conversión (desde C++11) dentro de la definición de su clase.

[editar] Notas

A un constructor con un solo parámetro no predeterminado (hasta C++11) que se declara sin el especificador de función explicit se le denomina constructor de conversión.

Ambos constructores (aparte del constructor de copia/movimiento) y las funciones de conversión definidas por el usuario pueden ser plantillas de función; el significado de explicit no cambia.

Un símbolo ( que sigue a explicit es analizado como parte del especificador explicit:

struct S {
    explicit (S)(const S&);    // ERROR en C++20, de acuerdo en C++17
    explicit (operator int)(); // ERROR en C++20, de acuerdo en C++17
};
(desde C++20)


Macro de prueba de característica Valor Estándar Comentario
__cpp_conditional_explicit 201806L (C++20) explicit(bool)

[editar] Ejemplo

struct A
{
    A(int) { }      // constructor de conversión
    A(int, int) { } // constructor de conversión (C++11)
    operator bool() const { return true; }
};
 
struct B
{
    explicit B(int) { }
    explicit B(int, int) { }
    explicit operator bool() const { return true; }
};
 
int main()
{
    A a1 = 1;      // de acuerdo: inicialización de copia selecciona a A::A(int)
    A a2(2);       // de acuerdo: inicialización directa selecciona a A::A(int)
    A a3 {4, 5};   // de acuerdo: inicialización directa de lista selecciona a 
                   //             A::A(int, int)
    A a4 = {4, 5}; // de acuerdo: inicialización de copia de lista selecciona a 
                   //             A::A(int, int)
    A a5 = (A)1;   // de acuerdo: conversión explícita realiza static_cast
    if (a1) ;      // de acuerdo: A::operator bool()
    bool na1 = a1; // de acuerdo: inicialización de copia selecciona a A::operator bool()
    bool na2 = static_cast<bool>(a1); // de acuerdo: static_cast realiza inicialización 
                                      //             directa
 
//  B b1 = 1;      // ERROR: inicialización de copia no considera a B::B(int)
    B b2(2);       // de acuerdo: inicialización directa selecciona a B::B(int)
    B b3 {4, 5};   // de acuerdo: inicialización directa de lista selecciona a 
                   //             B::B(int, int)
//  B b4 = {4, 5}; // ERROR: inicialización de copia de lista no considera a B::B(int,int)
    B b5 = (B)1;   // de acuerdo: conversión explícita realiza static_cast
    if (b2) ;      // de acuerdo: B::operator bool()
//  bool nb1 = b2; // ERROR: inicialización de copia no considera a B::operator bool()
    bool nb2 = static_cast<bool>(b2); // de acuerdo: static_cast realiza inicialización 
                                      //             directa
 
    [a4, a5, na1, na2, b5, nb2] { }; // puede suprimir las advertencias 
                                     // "variable no utilizada”
}


[editar] Véase también