Palabra clave explícita C ++

En C ++, utilizamos paréntesis y aparatos ortopédicos rizados para inicializar los elementos y pasar los parámetros para invocar diferentes constructores. Este tipo de inicialización se conoce como inicialización explícita. Explícito se utiliza antes del constructor, que se declara para que el constructor no requiere que la palabra clave "explícita" realice una conversión implícita. Se define para escapar de algunas conversiones implícitas si la clase contiene algún objeto, por lo que tiene un constructor de argumentos.

Los compiladores generalmente consideran conversiones implícitas o constructores de conversión. Esto puede resultar en un resultado indeseable. Para ignorar tales consecuencias, usamos la palabra "explícita" antes del constructor. En general, los constructores explícitos se declaran cuando los constríticos no están disponibles, y los constructores explícitos contienen uno o más parámetros. Cuando intentamos ejecutar el código que usa el especificador "explícito" en el constructor, encontramos un error de compilación.

Este artículo describe palabras clave explícitas utilizadas para constructores que no pueden utilizar un constrítico constrítico. Utilizamos el software "Dev C ++" para ejecutar los códigos.

Constructor de conversión explícito:

En C ++, los constructores se utilizan principalmente para inicializar o crear objetos para las clases entregadas por el compilador por defecto. Podemos usar este tipo de constructor para conversiones explícitas. Esta palabra clave explícita es opcional en la que pasamos solo un argumento a la vez. Este constructor se puede utilizar en estereotipos:

#incluir
usando el espacio de nombres STD;
Clase X
Char variable_a;
público:
X()
X (char a): variable_a (a) ;
void print () std :: cout << "Value is "<< variable_a <;
nulo disp (x i)

i.imprimir();

int main ()

X obj1 ('m');
X obj2 = 'n';
cout<<"When we call constructor normally, this is the value :" << endl;
disp (obj1);
cout<<"\n" <cout<<"We get this value after the compiler implicitly changes it to character type from X type is : " << endl;
disp (obj2);
regresar 0;

En este programa, primero definimos la clase "x" que declara la variable denominada "variable_a" de tipo de caracteres. Luego, hacemos que el constructor predeterminado tenga cero parámetros y el constructor de argumentos únicos con otra clase que tiene la "variable_a" del tipo de caracteres. El valor creado y luego se pasa como argumento a la función se imprime. Aquí, solo necesitamos pasar cualquier valor de tipo de personaje, pero en la función Main (), usamos el primer objeto llamado "OBJ1" de la clase X. Después de esto, pasamos la "M" como argumento a una función disp (). Por lo tanto, el valor se imprime cuando el constructor generalmente se llama.

Supongamos que creamos un segundo objeto, "obj2", de la clase X, y la función disp () se pasa. Entonces, pasaremos un argumento de la clase "x". Por lo tanto, si llamamos a la función disp () y asignamos el alfabeto "n" de tipo de caracteres de tipo a objeto "obj2", el compilador cambia indirectamente esta variable de tipo "x" a una variable de caracteres de tipo. Proporciona salida en el valor del personaje. Usamos un argumento y ponemos la palabra clave "explícita" en el constructor para evitar esto con una llamada implícita:

Compare dos números complejos:

Utilizamos la palabra clave "explícita" para el constructor definido para indicar que el constructor se llama explícitamente con la ayuda de aparatos ortopédicos y soportes cuadrados. El compilador arroja un error cuando el usuario intenta llamar a un constructor explícito con la ayuda de un operador de asignación "=".
En este código, creamos una clase "complejo_number". Luego, hacemos variables del tipo de datos dobles y ponemos estas variables en privado. Si la clase contiene un constructor en el que pasamos solo un argumento, ese constructor será un constructor de conversión. Podemos ignorar estas conversiones implícitas, ya que pueden darnos resultados inesperados. Por lo tanto, creamos explícitamente el constructor utilizando la palabra clave "explícita":

#incluir
usando el espacio de nombres STD;
Clase XYZ

privado:
int b;
int c;
público:
xyz (int u = 0, int v = 0): b (u), c (v)
operador de bool == (xyz e)
retorno (b == e.b && c == e.C)? falso verdadero;

;
int main ()

xyz obj (12, 23);
if (obj == 12)
cout << "matched";
demás
cout << "Not matched";
regresar 0;

En el cuerpo de la función principal, declaramos valores al objeto de la clase. Aplicamos la condición if-else para comparar dos números complejos. Aquí, verificamos si el valor dado aprobado como argumento es igual a los valores de un objeto. La salida del código anterior es el siguiente:

Usando dos argumentos:

Si no podemos controlar la conversión implícita, debemos requerir un constructor con una palabra clave explícita para el constructor en la afirmación de clase. No podemos utilizar esta palabra clave en el constructor predeterminado. En general, establecer la palabra clave "explícita" como identificador de función para un constructor que tiene uno o más parámetros en una declaración de clase se utiliza para proteger a la clase de conversiones de tipo innecesario. De lo contrario, sin esta palabra clave, podría ser un constructor de conversión:

#incluir
usando el espacio de nombres STD;
Clase complejo_number

privado:
doble rnum;
doble inum;
público:
Explícito complejo_number (doble r = 0.0, doble i = 0.0): rnum (r), inum (i)
operador bool == (complejo_number ABC)
return (rnum == ABC.rnum && inum == ABC.inum)? verdadero Falso;

;
int main ()

Comple_number comp (9.0, 4.0);
if (comp == (complejo_number) 7.0)
cout << "Same";
demás
cout << "Not Same";
regresar 0;

En este caso, creamos una clase llamada "xyz". Pasamos dos parámetros en el constructor. Generalmente es la mejor manera de usar explícitamente un constructor de argumentos. Ya que puede ser confuso si llamamos a dos o más argumentos para los constructores en la función principal. Nuevamente, aquí el constructor es declarado implícitamente por el compilador. Lógicamente, para evitar la implementación innecesaria del programa que pueda conducir a la producción, no es tan fácil convertir el tipo, así que utilice la palabra clave "explícita" en c ++ para el constructor:

Conclusión:

En este artículo, determinamos que la palabra clave específica "explícita" se utiliza típicamente para los constructores utilizados para hacer objetos de clase en la afirmación de clase. También notamos que la palabra clave explícita es la más efectiva para los constructores. Al mismo tiempo, necesitamos mantenernos alejados de las llamadas implícitas a través de los compiladores que generalmente crean los constructores como constructores cambiantes. Cambia las variables de un tipo a otro que no es preciso. Es una forma excepcional de usar constantemente esta palabra clave en tales casos. Esperamos que hayas encontrado este artículo útil. Consulte otros artículos de Sugerencia de Linux para obtener más consejos e información.