C++ Academy · Lección

Transformación de tipos

remove_const, decay y más

Transformación de tipos es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 2 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.

Transformaciones de tipos

Además de consultar información, <type_traits> puede producir nuevos tipos a partir de otros. Estos traits exponen un tipo miembro ::type, con un atajo _t desde C++14.

remove_const

std::remove_const_t<const int> produce int. Resulta útil cuando necesita una versión modificable de un tipo.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_const_t<const int>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

remove_reference

std::remove_reference_t<int&> produce int. Esto es fundamental para el reenvío perfecto y para escribir código genérico.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_reference_t<int&>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

add_pointer y add_const

Las transformaciones también añaden calificadores.

add_const_t<int> = const int
add_pointer_t<int> = int*

#include <iostream>
#include <type_traits>

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

std::decay

std::decay_t<T> imita las conversiones que se producen al pasar por valor: elimina las referencias y los calificadores cv, y convierte los arrays y las funciones en punteros.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::decay_t<const int&>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

Decaimiento de arrays

decay convierte un tipo array en un puntero, exactamente igual que al pasar un array a una función.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::decay_t<int[5]>;
    std::cout << std::is_same_v<T, int*> << "\n";
    return 0;
}

remove_cv

std::remove_cv_t<const volatile int> elimina tanto const como volatile, y produce el int simple.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_cv_t<const volatile int>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

common_type

std::common_type_t<A,B> proporciona el tipo al que ambos pueden convertirse, como el resultado de a + b.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::common_type_t<int, double>;
    std::cout << std::is_same_v<T, double> << "\n";
    return 0;
}

underlying_type

Para los enums, std::underlying_type_t<E> revela el tipo entero subyacente al enum.

#include <iostream>
#include <type_traits>

enum class Color : unsigned char { Red, Green };

int main() {
    using U = std::underlying_type_t<Color>;
    std::cout << std::is_same_v<U, unsigned char> << "\n";
    return 0;
}

Encadenar transformaciones

Las transformaciones se pueden componer. Para normalizar un tipo reenviado, a menudo se combinan, por ejemplo remove_cv_t<remove_reference_t<T>>, que es esencialmente lo que hace decay al principio.

Por qué son importantes las transformaciones

Las funciones genéricas reciben con frecuencia const T& o T&&, pero necesitan el tipo sin calificadores para declarar variables locales o valores de retorno. Los traits de transformación proporcionan ese tipo limpio.

Comprobación rápida

Recuerde qué hace decay.

Resumen

Ha aprendido las transformaciones de tipos.

Los traits exponen ::type con un atajo _t
remove_const, remove_reference, remove_cv
add_pointer, add_const, decay
common_type, underlying_type para obtener resultados derivados

Preguntas frecuentes

¿La lección «Transformación de tipos» es gratis?

Sí — el texto completo de «Transformación de tipos» 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 «Transformación de tipos»?

remove_const, decay y más 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 2 de 4.

¿Cuánto tiempo toma la lección «Transformación de tipos»?

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