C++ Academy · Aula

Transformação de tipos

Conheça remove_const, decay e outros

Transformação de tipos é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Transformações de Tipos

Além de consultar tipos, <type_traits> pode produzir novos tipos a partir de tipos existentes. Essas características expõem um tipo membro ::type, com um atalho _t disponível no C++14 ou posterior.

remove_const

std::remove_const_t<const int> produz int. É útil quando você precisa de uma versão mutável de um 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&> fornece int. Isso é fundamental para o encaminhamento perfeito e para escrever 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 e add_const

As transformações também adicionam qualificadores.

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 as conversões que ocorrem ao passar por valor: remove referências e qualificadores cv e converte matrizes e funções em ponteiros.

#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;
}

Decaimento de Matrizes

decay transforma um tipo de matriz em um ponteiro, exatamente como ao passar uma matriz para uma função.

#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> remove tanto const quanto volatile, produzindo um int simples.

#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> fornece o tipo para o qual ambos podem ser convertidos, como o 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 enumerações, std::underlying_type_t<E> revela o tipo inteiro subjacente à enumeração.

#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;
}

Encadeando Transformações

As transformações podem ser compostas. Para normalizar um tipo encaminhado, você frequentemente as combina, por exemplo, remove_cv_t<remove_reference_t<T>>, que é essencialmente o ponto de partida de decay.

Por que as Transformações são Importantes

Funções genéricas frequentemente recebem const T& ou T&&, mas precisam do tipo básico para declarar variáveis locais ou valores de retorno. As características de transformação fornecem esse tipo limpo.

Verificação Rápida

Relembre o que decay faz.

Recapitulação

Você aprendeu transformações de tipos.

As características expõem ::type com um atalho _t
remove_const, remove_reference, remove_cv
add_pointer, add_const, decay
common_type, underlying_type para resultados derivados

Perguntas Frequentes

A aula “Transformação de tipos” é grátis?

Sim — o texto completo de “Transformação de tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Transformação de tipos”?

Conheça remove_const, decay e outros Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Transformação de tipos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy