C++ / Argumentos type de templates

Bienvenidos sean a este post, hoy veremos otro tipo de argumento para templates.

En el post anterior vimos que es el argumentos non-type y comentamos que debemos respetar una regla: el argumento debe ser constante como el parametro non-type. En cambio, los argumentos type son mas simple y solo requieren que sea un typeid. El typeid es un operador de C++ que devuelve una informacion del tipo de identificacion en la ejecucion. Este es un objeto type_info que nos perrmite compararlo con otros objetos del mismo tipo. Para entender este concepto, vamos a analizar el siguiente ejemplo:

#include <iostream>
#include <typeinfo>

template<class T> class C {};
template<class T> void f() { std::cout << "T" << std::endl; }
template<int i> void f() { std::cout << i << std::endl; }

struct A {};
typedef struct {} B;

int main()
{
        std::cout << "id1: " << typeid(A).name() << ";\t";
        std::cout << "id2: " << typeid(A*).name() << ";\t";
        std::cout << "id3: " << typeid(B).name() << ";\t";
        std::cout << "id4: " << typeid(int()).name() << std::endl;

        return 0;
}

En este ejemplo, importaremos una nueva libreria para poder usar a la funcion typeid. Lo siguiente es definir tres template. El primero lo aplicaremos a una clase, los siguientes seran para una funcion y una sobrecarga de este. Pero para el ultimo caso, usaremos un parametro non-type. Lo siguiente es una struct vacia y un alias de un struct vacio. En el main, usaremos a varios typei para mostrar el nombre del objeto relacionado al struct A, a su puntero, al del alias de este y del tipo int. Compilemos y veamos como es la salida:

$ ./plantilla
id1: 1A;        id2: P1A;       id3: 1B;        id4: FivE
$

Como pueden ver sin importar el elemento tienen un objeto typeid. Por lo tanto, si creamos los siguientes objetos seran todos validos:

C<A> x1;
C<A*> x2;
C<B> x3;

Estos tres objetos son validos porque como vimos anteriormente tiene un objeto typeid y esto permite que se cumpla la regla para este tipo de argumentos. Tomemos el main y hagamos la siguiente modificacion:

int main()
{
        std::cout << "id1: " << typeid(A).name() << ";\t";
        std::cout << "id2: " << typeid(A*).name() << ";\t";
        std::cout << "id3: " << typeid(B).name() << ";\t";
        std::cout << "id4: " << typeid(int()).name() << std::endl;

        f<int()>();
        f<5>();

        return 0;
}

Simplemente agregamos dos llamados a la luncion que sobrecargamos. Compilemos y veamos que sucede:

$ ./plantilla
id1: 1A;        id2: P1A;       id3: 1B;        id4: FivE
T
5
$

Como pueden ver, funcionaron ambos llamados a la funcion. En el segundo caso, sabemos que iba a funcionar porque era un parametro non-type y le pasamos un argumento de este estilo. Pero lo curioso es el otro llamado porque pasamos a int() pero vean que al momento de usarlo con typeid nos devolvio el nombre del objeto. Por lo tanto, es considerado como un tipo y cumple la regla para poder usarlo. Como dijimos al inicio, siempre que tenga un objeto de typeid cumplira con la regla y podra ser utilizado y este lo hara mas simple de utilizar.

En resumen, hoy hemos visto a argumento type, que es, como se implementa, asi como un ejemplo para poder verlo en accion. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.