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++
CPP
// 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.
CPP
// 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.
CPP
// 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.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA