C++ Academy · Lección

Especialización completa

Personalice plantillas para un tipo

Especialización completa es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

Repaso: plantillas

Una plantilla permite que un fragmento de código funcione con muchos tipos. El compilador genera una versión concreta para cada tipo que utilice.

La forma general funciona con cualquier tipo.
A veces un tipo necesita un tratamiento especial.

#include <iostream>

template <typename T>
T maxOf(T a, T b) { return a > b ? a : b; }

int main() {
    std::cout << maxOf(3, 9) << ' ' << maxOf(2.5, 1.5) << '\n';
    return 0;
}

¿Qué es la especialización completa?

La especialización completa proporciona una implementación totalmente independiente para un tipo específico, reemplazando la plantilla general únicamente para ese tipo.

#include <iostream>

template <typename T>
void describe(T) { std::cout << "some type\n"; }

template <>
void describe(int) { std::cout << "an int\n"; }

int main() {
    describe(3.14);
    describe(42);
    return 0;
}

La sintaxis

Una especialización completa comienza con unos corchetes angulares vacíos, template <>, y especifica el tipo exacto en la especialización.

#include <iostream>

template <typename T>
struct TypeName { static const char* get() { return "unknown"; } };

template <>
struct TypeName<bool> { static const char* get() { return "bool"; } };

int main() {
    std::cout << TypeName<double>::get() << '\n';
    std::cout << TypeName<bool>::get() << '\n';
    return 0;
}

Especializar una plantilla de clase

Se pueden especializar plantillas de clase completas, lo que proporciona a un tipo sus propios miembros y un comportamiento distinto del de la plantilla principal.

#include <iostream>

template <typename T>
struct Storage {
    T value;
    void show() { std::cout << "value: " << value << '\n'; }
};

template <>
struct Storage<bool> {
    bool value;
    void show() { std::cout << (value ? "true" : "false") << '\n'; }
};

int main() {
    Storage<int> s{5}; s.show();
    Storage<bool> b{true}; b.show();
    return 0;
}

¿Por qué especializar?

La especialización permite tratar los tipos que necesitan una lógica diferente, como const char*, que necesita una comparación de cadenas en lugar de una comparación de punteros.

#include <iostream>
#include <cstring>

template <typename T>
bool equal(T a, T b) { return a == b; }

template <>
bool equal(const char* a, const char* b) { return std::strcmp(a, b) == 0; }

int main() {
    std::cout << std::boolalpha;
    std::cout << equal(5, 5) << '\n';
    std::cout << equal("hi", "hi") << '\n';
    return 0;
}

Especializar un solo miembro

En una plantilla de clase puede especializar solo una función miembro para un tipo determinado y reutilizar el resto.

#include <iostream>

template <typename T>
struct Printer {
    void print(T v) { std::cout << v << '\n'; }
};

template <>
void Printer<char>::print(char v) {
    std::cout << "char: " << v << '\n';
}

int main() {
    Printer<int>{}.print(7);
    Printer<char>{}.print('A');
    return 0;
}

La coincidencia exacta prevalece sobre la general

Cuando existe una especialización completa para el tipo exacto, el compilador siempre la prefiere a la plantilla principal.

#include <iostream>

template <typename T>
int rank() { return 0; }

template <>
int rank<double>() { return 99; }

int main() {
    std::cout << rank<int>() << ' ' << rank<double>() << '\n';
    return 0;
}

La especialización debe seguir a la plantilla principal

Una especialización debe declararse después de que la plantilla principal sea visible; de lo contrario, el compilador no tendrá nada que especializar.

#include <iostream>

template <typename T>
const char* kind() { return "generic"; }

template <>
const char* kind<float>() { return "float"; }

int main() {
    std::cout << kind<int>() << ' ' << kind<float>() << '\n';
    return 0;
}

Especializar plantillas de std

Puede especializar algunas plantillas de la biblioteca estándar, como std::hash, para sus propios tipos y hacer que funcionen con contenedores basados en hash.

#include <iostream>

struct Point { int x, y; };

template <typename T>
struct Hasher { size_t operator()(const T&) { return 0; } };

template <>
struct Hasher<Point> {
    size_t operator()(const Point& p) { return p.x * 31 + p.y; }
};

int main() {
    Hasher<Point> h;
    std::cout << h(Point{2, 3}) << '\n';
    return 0;
}

Especialización por valores

Los parámetros de plantilla que no son de tipo pueden especializarse para valores concretos, lo que resulta útil para las tablas en tiempo de compilación.

#include <iostream>

template <int N>
struct Fib { static const int value = Fib<N-1>::value + Fib<N-2>::value; };

template <>
struct Fib<0> { static const int value = 0; };

template <>
struct Fib<1> { static const int value = 1; };

int main() {
    std::cout << Fib<10>::value << '\n';
    return 0;
}

Mantenga un comportamiento coherente

Una especialización debe conservar el mismo contrato conceptual que la plantilla principal; solo debe cambiar la implementación. De lo contrario, quienes la usan recibirán sorpresas.

#include <iostream>

template <typename T>
T zero() { return T{}; }

template <>
int zero<int>() { return 0; }

int main() {
    std::cout << zero<int>() << ' ' << zero<double>() << '\n';
    return 0;
}

Comprobación rápida

Compruebe su comprensión de la sintaxis de la especialización completa.

Resumen

Ha aprendido sobre la especialización completa:

proporciona una implementación específica para un único tipo exacto
se escribe con template <> y el tipo concreto
el compilador siempre prefiere una especialización exacta
funciona con funciones, clases, miembros individuales y valores específicos

A continuación, verá la especialización parcial, que coincide con patrones de tipos.

Preguntas frecuentes

¿La lección «Especialización completa» es gratis?

Sí — el texto completo de «Especialización completa» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Especialización completa»?

Personalice plantillas para un tipo Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Especialización completa»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy