Plantilla de argumentos sin tipo en C++

Requisito previo: Plantillas en C++

En general, una plantilla de C++, con un solo argumento, se ve así:

template<tipo de nombre template_name>

Pero se ha visto que una plantilla puede tener múltiples argumentos. La sintaxis del mismo sería:

plantilla<clase T1, clase T2, clase T3, ………, clase Tn>

donde, n es el número de argumentos.

También es posible usar argumentos que no sean de tipo ( tipos de datos básicos/derivados ), es decir, además del argumento de tipo T, también puede usar otros argumentos como strings , nombres de funciones , expresiones constantes y tipos de datos integrados .

Ejemplo 1:

template <class T, int size>
class Array {
private:

    // Automatic array initialization
    T Arr[size]
    .....
    .....
};

Explicación:

En el ejemplo anterior, la plantilla proporciona el tamaño de la array como argumento. Esto implica que el compilador conoce el tamaño de la array en el momento mismo de la compilación . Los argumentos deben especificarse cada vez que se crea una clase de plantilla.

Ejemplo 2:

// Array of 10 integers
Array<int, 10> a1

// Array of 5 double type numbers
Array<double, 5> a2

// String of size 9 
Array<char, 10>  a3 

where size is given as an argument to the template class.

Los siguientes son los argumentos que están permitidos:

• Expresiones constantes
• Direcciones de función u objetos con enlace externo
• Direcciones de miembros de clase estática .

A continuación se muestra el programa para ilustrar las plantillas sin tipo:

// C++ program to implement bubble sort
// by using Non-type as function parameters
#include <iostream>
using namespace std;
  
// Function to swap two numbers
template <class T>
void swap_(T* x, T* y)
{
    T temp = *x;
    *x = *y;
    *y = temp;
}
  
// Function to implement the Bubble Sort
template <class T, int size>
void bubble_sort(T arr[])
{
    for (int i = 0; i < size - 1; i++) {
  
        // Last i elements are already
        // in place
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
  
                // Swap operation
                swap_(&arr[j], &arr[j + 1]);
            }
        }
    }
}
  
// Function to print an array
template <class T, int size>
void printArray(T arr[])
{
    int i;
    for (i = 0; i < size - 1; i++) {
        cout << arr[i] << ", ";
    }
  
    cout << arr[size - 1] << endl;
}
  
// Driver Code
int main()
{
    // Given array arr[]
    float arr[] = { 1.1, 1.2, 0.3, 4.55, 1.56, 0.6 };
    const int size_arr = sizeof(arr) / sizeof(arr[0]);
  
    // Size of the array passed as
    // an argument to the function
    bubble_sort<float, size_arr>(arr);
  
    cout << "Sorted Array is: ";
    printArray<float, size_arr>(arr);
  
    return 0;
}

Sorted Array is: 0.3, 0.6, 1.1, 1.2, 1.56, 4.55