Herencia de plantilla de clase en C++

1. Plantillas en C++
2. Plantillas de funciones en C++
3. Plantillas de clase en C++
4. Herencia de plantilla de clase en C++

Este artículo discutirá uno de los métodos más populares y de uso frecuente en C++ (es decir, plantillas de clase).

La adición de plantillas a C++ marcó el comienzo de un nuevo paradigma de codificación conocido como programación genérica. Este es ahora un elemento importante del kit de herramientas del programador de C++, la base de gran parte de la biblioteca estándar, y algo que muchos de nosotros, los nuevos piratas informáticos de C++, nunca habíamos encontrado antes.

La programación genérica a veces se contrasta con el concepto de herencia en la programación orientada a objetos. Por otro lado, un verdadero enfoque multiparadigma requiere observar cómo interactúan los dos.

Plantillas en C++

En C++, una plantilla es una herramienta básica pero poderosa. La idea básica es pasar el tipo de datos como parámetro, eliminando la necesidad de escribir el mismo código para múltiples tipos de datos.

Una empresa de software, por ejemplo, puede requerir sort() para muchos tipos de datos. En lugar de escribir y mantener numerosos códigos, podemos construir una única función sort() y pasar el tipo de datos como parámetro.

C++ agregó dos nuevas palabras clave para admitir plantillas: template y typename. La palabra clave clase siempre se puede utilizar en lugar de la segunda palabra clave.

Sintaxis:

template <typename T>
void myFunction(T var )
{
    //function definition
}

En la sintaxis que se muestra arriba, podemos ver que para definir una función que acepta una variable de plantilla como parámetro, agregamos una línea template<typename T>. Ahora, esta función es elegible para aceptar un parámetro de cualquier tipo de datos; es una función genérica utilizada para int, char y muchos otros tipos de datos.

Cómo funcionan las plantillas en C++

Las plantillas se expanden durante el proceso de compilación. Esto es similar a las macros.

Por otro lado, el compilador realiza la verificación de tipos antes de la expansión de la plantilla. El concepto es sencillo: el código fuente solo contiene una función o clase, mientras que el código generado puede tener numerosas copias de la misma función o clase.

Esto se desarrolla en el siguiente ejemplo.

#include <iostream>
using namespace std;

template <typename T>
T checkMaxValue(T a, T b) {
  if (a > b)
    return a;
  else if (b > a)
    return b;
  else
    return 0;
}

// driver program
int main() {
  cout << checkMaxValue(102, 204) << endl;  // int value
  cout << checkMaxValue('c', 'f') << endl;  // char value
}

Tenga en cuenta que hemos pasado dos enteros a la función en la primera línea del programa del controlador, y eventualmente devolverá el valor entero máximo entre ambos. Hemos pasado dos valores de char a la misma función en la segunda línea, y la función devolverá el valor de char máximo.

En tiempo de compilación, llamamos a la función como se muestra a continuación:

int checkMaxValue(int a, int b)

Y para la segunda convocatoria escribimos lo siguiente:

char checkMaxValue(char a, char b)

Podemos ver que se crean múltiples copias de la misma función en tiempo de compilación dependiendo del tipo de variable pasada al llamar a la función.

Podemos usar plantillas para funciones y clases. Discutiremos ambos tipos y cómo implementar ambos.

Plantillas de funciones en C++

Crearemos una función genérica que pueda trabajar con varios tipos de datos. Sort(), max(), min() y printArray son ejemplos de plantillas de funciones.

Código de ejemplo:

template <class T>
void sortArray(T arr[], int s) {
  for (int i = 0; i < s - 1; i++)
    for (int j = s - 1; i < j; j--)
      if (arr[j] < arr[j - 1]) {
        int var = arr[j];
        arr[j] = arr[j - 1];
        arr[j - 1] = var;
      }
  cout << " Sorted array : ";
  for (int i = 0; i < s; i++) cout << arr[i] << " ";
  cout << endl;
}

// Driver Code
int main() {
  int a[5] = {10, 50, 30, 40, 20};
  int n = 5;
  sortArray<int>(a, n);

  char c[5] = {'g', 'a', 'i', 'h', 'e'};
  sortArray<char>(c, n);
  return 0;
}

Producción:

En el fragmento de código, hemos creado una función sortArray() que puede aceptar un tipo de matriz de plantilla y el valor de tamaño de esa matriz e imprimir la matriz ordenada. Lo hemos llamado para dos tipos de matrices diferentes en el código principal: matrices int y char.

En consecuencia, podemos usar cualquier tipo de datos y funcionará la misma función. Ahorra tiempo y espacio y también es eficiente en la programación genérica.

Plantillas de clase en C++

Las plantillas de clase, como las plantillas de funciones, son útiles cuando una clase ha estado definiendo algo que no depende del tipo de datos. LinkedList, BinaryTree, Stack, Queue, Array y más clases pueden beneficiarse de las plantillas de clase.

Sintaxis:

template <class T>
class className {
 private:
  T a;
  ........public : T myFunc(T x);
  ........
};

En esta sintaxis, T es el tipo de plantilla que se utiliza como marcador de posición para el tipo de datos. Al crear un objeto para esta clase de plantilla, se utiliza la siguiente sintaxis:

className<dataType> objectName;

De manera similar, podemos escribirlo usando esta sintaxis:

className<int> objectName;
className<double> objectName;

Ejemplo:

#include <iostream>
using namespace std;

template <class T>
class Number {
 private:
  T numb;

 public:
  Number(T a) : numb(a) {}

  T get() { return numb; }
};

int main() {
  Number<int> integerNumber(50);
  Number<double> doubleNumber(8.9);
  cout << "integer Number = " << integerNumber.get() << endl;
  cout << "double Number = " << doubleNumber.get() << endl;
  return 0;
}

Producción:

Puede ver en este ejemplo que la misma clase puede aceptar un número entero y un número doble. Este ejemplo es muy genérico para que entienda el concepto de plantillas de clase.

Este concepto se puede expandir y se pueden implementar muchas clases usando plantillas como LinkedList, Stack, Queue, etc.

Herencia de plantilla de clase en C++

La herencia de una clase de plantilla es factible. Se aplican todas las reglas regulares de herencia y polimorfismo.

Si necesitamos que la nueva clase derivada sea general, debemos convertirla en una clase de plantilla con un argumento de plantilla enviado a la clase base. Esto se debe a que la herencia solo es posible con una clase, y una plantilla no es una clase a menos que se cree una instancia pasándole algún tipo de datos.

Sintaxis:

template <class T>
class derived : public Base<T>{};

Ejemplo:

#include <iostream>
using namespace std;

template <class T>
class Base {
 private:
  T val;

 public:
  void setVal(T a) { val = a; }
};
template <class T>
class Derived : public Base<T> {
 public:
  void setVal(T b) { Base<T>::setVal(b); }
};
int main() {
  Derived<int> a;
  a.setVal(4);
  return 0;
}

Creamos una plantilla de clase Base que contiene una variable de tipo de plantilla y una función miembro en el fragmento de código. Además, hemos creado una clase derivada que también es una plantilla de clase y amplía la plantilla de clase Base.

Al extender la clase Base, debemos especificar la variable de plantilla como Base<T>. La clase Base es genérica, y la clase derivada también es genérica.

La clase derivada también puede tener sus parámetros de plantilla. El ejemplo anterior se puede modificar de la siguiente manera:

template <class T, class S>
class Derived : public Base<T> {
 private:
  S data;

 public:
  void setVal(T b) {
    Base<T>::setVal(b);
    data = b;
  }
};

Entonces, podemos ver que la herencia también se puede implementar usando plantillas de clase. Además, podemos implementar clases de polimorfismo y adaptadores con plantillas de clase.