Funciones virtuales en C++

1. Funciones virtuales en C++
2. Reglas de funciones virtuales en C++
3. Comprender las funciones virtuales puras en C++

Este artículo enseñará sobre las funciones virtuales en C++. Las funciones virtuales son funciones miembro especiales que están sobrecargadas o anuladas por las derivadas declaradas pero definidas y declaradas en una clase base.

Funciones virtuales en C++

La palabra clave virtual se antepone antes de la declaración de la función en la clase base. Esto hace que el compilador realice un enlace tardío, también conocido como enlace dinámico en la función.

La vinculación tardía o vinculación dinámica en el compilador en tiempo de ejecución decide el tipo de objeto y vincula la llamada a la función. En palabras simples, es un tipo de enlace donde la llamada a la función se resuelve durante el tiempo de ejecución.

El polimorfismo en tiempo de ejecución se logra utilizando estas funciones. Entonces, siempre que una función en C++ se vuelve virtual, el compilador en tiempo de ejecución decide a qué función tiene que llamar en función del objeto señalado por el puntero de la clase base.

Código de ejemplo:

#include <bits/stdc++.h>
using namespace std;

class demo {
 public:
  virtual void fun() { cout << "Inside the base class\n"; }

  void check() { cout << "Base class function\n"; }
};

class derived : public demo {
 public:
  void fun() { cout << "Inside the derived class\n"; }

  void check() { cout << "Derived class fuction\n"; }
};

int main() {
  demo *ptr;
  derived d;
  ptr = &d;

  ptr->fun();

  ptr->check();
}

Producción :

Inside the derived class
Base class function

En el código anterior, dado que ptr->fun() es una función virtual, se vincula en tiempo de ejecución, mientras que ptr->check() es una función no virtual, por lo que se vincula en tiempo de compilación. Aquí, el polimorfismo en tiempo de ejecución se logró utilizando el puntero de la clase base, que apunta al objeto de la clase derivada.

Reglas de funciones virtuales en C++

Debemos tener en cuenta las siguientes reglas a la hora de trabajar con funciones virtuales.

1. No podemos tener constructores virtuales, pero podemos tener un destructor virtual. El uso de destructores virtuales garantiza que los objetos de clase derivados se destruyan en el orden correcto; primero, se destruye el objeto de la clase base y luego se destruye la clase derivada.

   Código de ejemplo:

   #include <bits/stdc++.h>
   using namespace std;
   
   class demo {
    public:
     demo() { cout << "Constructing base class\n"; }
   
     virtual ~demo() { cout << "Destroying base class\n"; }
   };
   
   class derived : public demo {
    public:
     derived() { cout << "Constructing derived class\n"; }
   
     virtual ~derived() { cout << "Destroying the derived class\n"; }
   };
   
   int main() {
     demo *ptr;
     derived *derivedPtr = new derived();
   
     ptr = derivedPtr;
   
     delete ptr;
   }
   

   Salida: Podemos observar que se sigue el orden adecuado de construcción y destrucción.

   Constructing base class
   Constructing derived class
   Destroying the derived class
   Destroying base class
   

2. Solo se deben usar punteros de clase base o referencias de clase base con funciones virtuales cuando queremos lograr polimorfismo en tiempo de ejecución.
3. Las funciones virtuales nunca pueden ser estáticas.
4. El prototipo de función virtual debe permanecer igual en las clases base y derivadas.
5. Las funciones virtuales también pueden ser una función amiga de otra clase.

Comprender las funciones virtuales puras en C++

Estas funciones son ligeras variaciones de las funciones virtuales originales. Una función virtual pura es una función virtual que no hace nada.

Sintaxis:

virtual void fun() = 0

Las funciones virtuales puras se utilizan para crear clases abstractas. Estas son clases cuyos objetos no se pueden crear, y las clases que se derivan de estos deben anular la función virtual pura; de lo contrario, también serán tratados como una clase abstracta.

Código de ejemplo:

#include <bits/stdc++.h>
using namespace std;

class demo {
 public:
  virtual void fun() = 0;
};

class derived : public demo {
 public:
  void fun()  // overriding the function
  {
    cout << "Inside the derived class";
  }
};

int main() {
  demo *ptr;

  // demo d;  This will give compile error as base class demo is abstract class

  derived d;
  ptr = &d;

  ptr->fun();
}

Producción :

Inside the derived class