C++ Academy · Lección

Escritura de traits personalizados

Cree sus propios traits de tipos

Escritura de traits personalizados es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 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.

Crear sus propios traits

Cuando la biblioteca estándar no ofrece la comprobación que necesita, puede escribir un trait personalizado. Un trait es simplemente una plantilla que expone ::value o ::type.

Plantilla primaria + especialización

El patrón estándar consiste en una plantilla primaria cuyo valor predeterminado es false, junto con una especialización que coincide con el tipo de interés y establece true.

#include <iostream>
#include <type_traits>

template <typename T>
struct is_ptr : std::false_type {};

template <typename T>
struct is_ptr<T*> : std::true_type {};

int main() {
    std::cout << is_ptr<int>::value << "\n";
    std::cout << is_ptr<int*>::value << "\n";
    return 0;
}

Heredar de integral_constant

Al heredar de std::true_type o std::false_type, su trait obtiene automáticamente un miembro value y se comporta como los traits estándar.

Detector de contenedores

Detecte si un tipo se comporta como un contenedor comprobando la existencia de miembros anidados. Aquí se especializa según la presencia de un alias de tipo value_type mediante un auxiliar.

#include <iostream>
#include <vector>
#include <type_traits>

template <typename T, typename = void>
struct has_value_type : std::false_type {};

template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

int main() {
    std::cout << has_value_type<std::vector<int>>::value << "\n";
    std::cout << has_value_type<int>::value << "\n";
    return 0;
}

Explicación de std::void_t

std::void_t<...> convierte cualquier lista de tipos válida en void. Si alguno de los tipos internos no es válido, la especialización se descarta mediante SFINAE, por lo que se utiliza el false_type primario.

Detectar una función miembro

Puede detectar si un tipo tiene un size() invocable comprobando la expresión dentro de un void_t.

#include <iostream>
#include <string>
#include <type_traits>

template <typename T, typename = void>
struct has_size : std::false_type {};

template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>> : std::true_type {};

int main() {
    std::cout << has_size<std::string>::value << "\n";
    std::cout << has_size<int>::value << "\n";
    return 0;
}

declval

std::declval<T>() produce un valor ficticio de tipo T en contextos no evaluados, lo que permite escribir expresiones decltype sin construir un objeto.

Un trait de transformación

Los traits personalizados también pueden producir tipos. Este elimina un nivel de puntero.

#include <iostream>
#include <type_traits>

template <typename T>
struct remove_one_pointer { using type = T; };

template <typename T>
struct remove_one_pointer<T*> { using type = T; };

int main() {
    using R = remove_one_pointer<int*>::type;
    std::cout << std::is_same_v<R, int> << "\n";
    return 0;
}

Proporcionar auxiliares _v y _t

Siga el estilo estándar añadiendo plantillas de variables y alias.

#include <iostream>
#include <type_traits>

template <typename T>
struct is_char : std::false_type {};
template <>
struct is_char<char> : std::true_type {};

template <typename T>
inline constexpr bool is_char_v = is_char<T>::value;

int main() {
    std::cout << is_char_v<char> << "\n";
    std::cout << is_char_v<int> << "\n";
    return 0;
}

Patrón de detección

La técnica de void_t se generaliza en el patrón de detección, que la experimental std::is_detected formaliza. Los conceptos de C++20 simplifican gran parte de esto.

Probar sus traits

Verifique los traits personalizados con static_assert para que cualquier regresión interrumpa inmediatamente la compilación.

#include <type_traits>

template <typename T>
struct is_void_like : std::false_type {};
template <>
struct is_void_like<void> : std::true_type {};

static_assert(is_void_like<void>::value);
static_assert(!is_void_like<int>::value);

int main() { return 0; }

Comprobación rápida

Recuerde la función de std::void_t.

Resumen

Ha aprendido a escribir traits personalizados.

La plantilla primaria tiene false como valor predeterminado; la especialización establece true
Herede de true_type/false_type
void_t + declval proporcionan la base del patrón de detección
Añada auxiliares _v/_t y pruebe con static_assert

Preguntas frecuentes

¿La lección «Escritura de traits personalizados» es gratis?

Sí — el texto completo de «Escritura de traits personalizados» 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 «Escritura de traits personalizados»?

Cree sus propios traits de tipos 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 4 de 4.

¿Cuánto tiempo toma la lección «Escritura de traits personalizados»?

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