Sin embargo, podría existir un destructor virtual. Aquí, mostraremos lo que sucede cuando creamos un constructor virtual en C++, así como el funcionamiento del destructor virtual en lugar del constructor virtual.
Ejemplo 1:
Creemos el constructor virtual y comencemos nuestro código colocando el archivo de encabezado 'iostream'. Este archivo de encabezado es para las funciones que se declaran en él como 'cin' y 'cout'. Después de esto, agregamos el espacio de nombres 'std', por lo que no podemos agregar este 'std' con todas las funciones de nuestro código. Después de esto, creamos una clase que es la clase base de nuestro código con el nombre 'my_base' y luego agregamos 'public' para crear el constructor virtual.
El constructor virtual se crea aquí colocando la palabra clave 'virtual'. Dentro de este constructor virtual, colocamos una declaración 'cout'. Debajo de esto, creamos una función llamada 'mostrar' en la que utilizamos 'cout' nuevamente. Después de esto, creamos una clase derivada de esta clase base con el nombre 'my_derived' y luego establecemos el constructor 'my_derived()' en el campo 'público'. Insertamos una declaración 'cout' en este constructor 'my_derived()'. Debajo, construimos una función llamada 'mostrar' donde hacemos uso del 'cout' una vez más.
Ahora, después de invocar “main()”, creamos un puntero de la clase base con el nombre “my_ptr” y también creamos el objeto de la clase derivada que es “Obj_d”. Después de esto, asignamos la dirección del “Obj_d” al “my_ptr”. Luego, llamamos a la función 'show()' a través de 'my_ptr'.
Código 1:
#incluir
usando espacio de nombres enfermedad de transmisión sexual ;
clase mi_base
{
público :
virtual mi_base ( )
{
corte << 'Aquí está mi clase base' << fin ;
}
vacío espectáculo ( )
{
corte << 'la función show de la clase base' << fin ;
}
} ;
clase mi_derivado : público mi_base
{
público :
mi_derivado ( )
{
corte << 'Aquí está mi clase derivada' << fin ;
}
vacío espectáculo ( )
{
corte << 'la función mostrar de la clase derivada' < espectáculo ( ) ;
}
Producción:
Aquí, muestra un mensaje de error que dice que el constructor no puede declararse virtual en la programación C++. Entonces, podemos ver que C++ no nos permite generar el constructor virtual pero sí podemos crear el destructor virtual.
Ejemplo 2:
Resolvamos el problema anterior y creemos el destructor virtual en este código. Luego de declarar la clase “new_base”, colocamos el constructor “público” en el cual creamos el destructor virtual agregando “virtual ~” con el “new_base”. Insertamos una declaración 'cout' en este destructor virtual. Debajo, construimos una función llamada 'mostrar' que hace uso de 'cout'. A continuación, creamos una clase derivada que es 'new_derived' de esta clase base 'new_base' y construimos el destructor 'new_derived()' en el campo 'público'. A este destructor “new_derived()” ahora se le ha agregado una declaración “cout”.
Debajo, creamos una función llamada 'mostrar' que usa la declaración 'cout' nuevamente. Después de llamar a la función 'main()', ahora producimos un objeto de la clase derivada 'obj_d', así como un puntero de la clase base llamado 'ptr1'. A continuación, le damos la dirección 'obj_d' al 'ptr1'. A continuación, se invoca el método “show()” usando “ptr1”.
Código 2:
#incluirusando espacio de nombres enfermedad de transmisión sexual ;
clase nueva_base
{
público :
virtual ~nueva_base ( )
{
corte << 'El destructor de la clase base está aquí' << fin ;
}
vacío espectáculo ( )
{
corte << 'La función show de la clase base' << fin ;
}
} ;
clase nuevo_derivado : público nueva_base
{
público :
~nuevo_derivado ( )
{
corte << 'El destructor de clases derivadas está aquí' << fin ;
}
vacío espectáculo ( )
{
corte << 'La función show de la clase base' < espectáculo ( ) ;
}
Producción:
Este programa utiliza un objeto puntero de 'new_base' que apunta a la clase derivada 'obj_d'. Por lo tanto, primero llama al método 'show()' de la clase 'new_base'. Luego, llama al método “~new_derived()” de la clase “new_derived” y muestra la “~new_base” de la clase base.
Ejemplo 3:
Aquí hay otro código para generar el constructor 'virtual'. Después de incluir el espacio de nombres “iostream” y “std”, generamos una clase “B”. Debajo de esto, creamos el constructor 'público' que es 'B()' y luego generamos el 'cout'. Las funciones constructora y destructora se definen utilizando un especificador de acceso 'público' al que cualquier objeto de la clase puede llamar.
Ahora, también creamos el destructor “~B()” de esta clase base en el que utilizamos “cout” nuevamente. Luego, creamos la clase 'D', que es la clase derivada de la clase base 'B', y colocamos el 'público' aquí. Dentro de este “público”, creamos el constructor así como el destructor de la clase derivada con los nombres “D()” y “~D”, respectivamente. Ambos contienen el “cout” en su interior. Ahora tenemos la función 'principal()'. Después de llamar a esta función, generamos el objeto puntero de la clase base.
Luego, usamos la palabra clave 'eliminar' y colocamos 'base_ptr' aquí. En este caso, el espacio del destructor se elimina llamando al objeto puntero de la clase base.
Código 3:
#incluirusando espacio de nombres enfermedad de transmisión sexual ;
clase B
{
público :
B ( )
{
corte << 'Constructor de la clase Base' << fin ;
}
~B ( )
{
corte << 'Destructor de la clase Base' << fin ;
}
} ;
clase D : público B
{
público :
D ( )
{
corte << 'Constructor de la clase Derivada' << fin ;
}
~D ( )
{
corte << 'Destructor de la clase Derivada' << fin ;
}
} ;
En t principal ( )
{
B * base_ptr = nuevo D ;
borrar base_ptr ;
}
Producción:
El resultado muestra que utiliza un objeto puntero que apunta a la clase 'B' en la función principal. Por lo tanto, llama primero al “constructor()” de la clase “B”. Luego, llama al “constructor()” de la clase “D”. Luego se elimina el objeto puntero que contienen los destructores de las clases 'B' y 'D'. Sin invocar el destructor de la clase “D” dentro del programa, el puntero de la clase “B” solo elimina el destructor de la clase “B”. Como resultado, la memoria del programa está dañada.
Conclusión
Discutimos el concepto de 'construcción virtual' en la programación C++. Exploramos que no podemos crear el constructor virtual en C++, pero podemos crear el destructor virtual en nuestros códigos. Aquí, mostramos lo que sucedió cuando creamos el constructor virtual en programación C++ y el funcionamiento del destructor virtual en nuestros códigos. Aprendimos que el constructor no puede ser virtual, pero podemos generar el destructor virtual en nuestra clase. Demostramos algunos ejemplos y explicamos estos códigos detalladamente en esta guía.