Uso de palabra clave explícita en C++

La palabra clave explícita en C++ se usa para marcar constructores para que no conviertan implícitamente tipos en C++. Es opcional para los constructores que toman exactamente un argumento y trabajan en constructores (con un solo argumento), ya que esos son los únicos constructores que se pueden usar en el encasillado.

Comprendamos la palabra clave explícita a través de un ejemplo. 

Prediga la salida del siguiente programa C++

// C++ program to illustrate default
// constructor without 'explicit'
// keyword
#include <iostream>
using namespace std;
 
class Complex {
private:
    double real;
    double imag;
 
public:
   
    // Default constructor
    Complex(double r = 0.0,
            double i = 0.0) : real(r),
                              imag(i)
    {
    }
 
    // A method to compare two
    // Complex numbers
    bool operator == (Complex rhs)
    {
        return (real == rhs.real &&
                imag == rhs.imag);
    }
};
 
// Driver Code
int main()
{
    // a Complex object
    Complex com1(3.0, 0.0);
 
    if (com1 == 3.0)
        cout << "Same";
    else
        cout << "Not Same";
    return 0;
}

Same

Como se explica en este artículo , en C++, si una clase tiene un constructor al que se puede llamar con un único argumento, este constructor se convierte en un constructor de conversión porque dicho constructor permite la conversión del único argumento a la clase que se está construyendo. 
Podemos evitar este tipo de conversiones implícitas, ya que pueden dar lugar a resultados inesperados . Podemos hacer que el constructor sea explícito con la ayuda de una palabra clave explícita . Por ejemplo, si probamos el siguiente programa que usa palabras clave explícitas con un constructor, obtenemos un error de compilación.

// C++ program to illustrate
// default constructor with
// 'explicit' keyword
#include <iostream>
using namespace std;
 
class Complex {
private:
    double real;
    double imag;
 
public:
    // Default constructor
    explicit Complex(double r = 0.0,
                     double i = 0.0) :
                     real(r), imag(i)
    {
    }
 
    // A method to compare two
    // Complex numbers
    bool operator == (Complex rhs)
    {
        return (real == rhs.real &&
                imag == rhs.imag);
    }
};
 
// Driver Code
int main()
{
    // a Complex object
    Complex com1(3.0, 0.0);
 
    if (com1 == 3.0)
        cout << "Same";
    else
        cout << "Not Same";
    return 0;
}

Producción

Compiler Error : no match for 'operator==' in 'com1 == 3.0e+0'

Todavía podemos encasillar los valores dobles a Complejo, pero ahora tenemos que encasillarlos explícitamente. Por ejemplo, el siguiente programa funciona bien.

// C++ program to illustrate
// default constructor with
// 'explicit' keyword
#include <iostream>
using namespace std;
 
class Complex {
private:
    double real;
    double imag;
 
public:
   
    // Default constructor
    explicit Complex(double r = 0.0,
                     double i = 0.0):
                     real(r) , imag(i)
    {
    }
 
    // A method to compare two
    // Complex numbers
    bool operator == (Complex rhs)
    {
        return (real == rhs.real &&
                imag == rhs.imag);
    }
};
 
// Driver Code
int main()
{
    // a Complex object
    Complex com1(3.0, 0.0);
 
    if (com1 == (Complex)3.0)
        cout << "Same";
    else
        cout << "Not Same";
    return 0;
}

Same

Nota: El especificador explícito se puede usar con una expresión constante. Sin embargo, si esa expresión constante se evalúa como verdadera, entonces solo la función es explícita.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.