C++ Academy · Aula

Escrita de traits personalizados

Crie seus próprios traits de tipos

Escrita de traits personalizados é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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.

Criando suas próprias características

Quando a biblioteca padrão não oferece a verificação de que você precisa, é possível escrever uma característica personalizada. Uma característica é simplesmente um modelo que expõe ::value ou ::type.

Modelo primário + especialização

O padrão usual: um modelo primário cujo valor padrão é false, além de uma especialização que corresponde ao tipo de interesse e define 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;
}

Herdando de integral_constant

Ao herdar de std::true_type ou std::false_type, sua característica obtém automaticamente um membro value e se comporta como as características padrão.

Um detector de contêineres

Detecte se um tipo se parece com um contêiner verificando a existência de membros aninhados. Aqui, especializamos o tipo quando há um alias value_type, usando um 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;
}

std::void_t explicado

std::void_t<...> mapeia qualquer lista de tipos válidos para void. Se algum tipo interno for malformado, a especialização é descartada por meio de SFINAE, então o false_type primário vence.

Detectando uma função membro

Você pode detectar se um tipo possui um size() chamável testando a expressão em um 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>() produz um valor fictício do tipo T em contextos não avaliados, permitindo escrever expressões decltype sem construir um objeto.

Uma característica de transformação

As características personalizadas também podem produzir tipos. Esta remove uma camada de ponteiro.

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

Fornecendo auxiliares _v e _t

Siga o estilo da biblioteca padrão adicionando modelos de variável e de 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;
}

Idioma de detecção

A técnica void_t é generalizada no idioma de detecção, formalizado pelo std::is_detected experimental. Os conceitos do C++20 tornam grande parte disso mais simples.

Testando suas características

Verifique as características personalizadas com static_assert, para que qualquer regressão interrompa imediatamente a compilação.

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

Verificação rápida

Relembre a função de std::void_t.

Recapitulação

Você aprendeu a escrever características personalizadas.

O modelo primário assume false; a especialização define true
Herde de true_type/false_type
void_t + declval dão suporte ao idioma de detecção
Adicione auxiliares _v/_t e teste com static_assert

Perguntas Frequentes

A aula “Escrita de traits personalizados” é grátis?

Sim — o texto completo de “Escrita de traits personalizados” é 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 “Escrita de traits personalizados”?

Crie seus próprios traits de tipos 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 4 de 4.

Quanto tempo leva a aula “Escrita de traits personalizados”?

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