C++ Academy · Aula

Especialização parcial

Especialize padrões de templates

Especialização parcial é 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.

O que é Especialização Parcial?

A especialização parcial personaliza um modelo para uma família de tipos que compartilham um padrão, em vez de um único tipo exato.

Apenas modelos de classe oferecem suporte a ela.
Você ainda deixa alguns parâmetros genéricos.

#include <iostream>

template <typename T>
struct Traits { static const char* kind() { return "value"; } };

template <typename T>
struct Traits<T*> { static const char* kind() { return "pointer"; } };

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

Correspondência de Ponteiros

O padrão T* corresponde a qualquer tipo de ponteiro, permitindo tratar todos os ponteiros com uma única especialização.

#include <iostream>

template <typename T>
struct Deref { static T get(T v) { return v; } };

template <typename T>
struct Deref<T*> { static T get(T* p) { return *p; } };

int main() {
    int x = 42;
    std::cout << Deref<int>::get(7) << '\n';
    std::cout << Deref<int*>::get(&x) << '\n';
    return 0;
}

Funções não Podem ser Especializadas Parcialmente

Apenas modelos de classe (e de variáveis) oferecem suporte à especialização parcial. Para funções, você usa sobrecarga.

#include <iostream>

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

template <typename T>
void show(T*) { std::cout << "pointer\n"; }

int main() {
    int x = 0;
    show(5);
    show(&x);
    return 0;
}

Especializando um de Dois Parâmetros

Com vários parâmetros de tipo, você pode fixar um e deixar o outro aberto, correspondendo a um padrão entre tipos.

#include <iostream>

template <typename A, typename B>
struct Pair { static const char* kind() { return "mixed"; } };

template <typename A>
struct Pair<A, A> { static const char* kind() { return "same types"; } };

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

Correspondência de Matrizes

Você pode fazer a correspondência de tipos de matriz com um padrão que captura o tipo do elemento e o tamanho como um parâmetro que não é de tipo.

#include <iostream>

template <typename T>
struct Info { static int size() { return 1; } };

template <typename T, int N>
struct Info<T[N]> { static int size() { return N; } };

int main() {
    std::cout << Info<int>::size() << '\n';
    std::cout << Info<int[5]>::size() << '\n';
    return 0;
}

Padrões de Const

Uma especialização pode remover ou detectar const ao corresponder const T como um padrão.

#include <iostream>

template <typename T>
struct IsConst { static const bool value = false; };

template <typename T>
struct IsConst<const T> { static const bool value = true; };

int main() {
    std::cout << std::boolalpha;
    std::cout << IsConst<int>::value << '\n';
    std::cout << IsConst<const int>::value << '\n';
    return 0;
}

Vence a Mais Especializada

Quando várias especializações podem corresponder, o compilador escolhe a mais especializada, ou seja, o padrão mais específico.

#include <iostream>

template <typename T>
struct K { static int v() { return 0; } };

template <typename T>
struct K<T*> { static int v() { return 1; } };

template <>
struct K<int*> { static int v() { return 2; } };

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

Padrões de Referência

Você também pode corresponder a tipos de referência, distinguindo uma referência de um valor simples.

#include <iostream>

template <typename T>
struct Cat { static const char* k() { return "value"; } };

template <typename T>
struct Cat<T&> { static const char* k() { return "lvalue ref"; } };

int main() {
    std::cout << Cat<int>::k() << '\n';
    std::cout << Cat<int&>::k() << '\n';
    return 0;
}

Criando Traços de Tipos

A especialização parcial é o mecanismo por trás dos traços de tipos. Veja aqui um remove_pointer criado manualmente.

#include <iostream>
#include <type_traits>

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

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

int main() {
    std::cout << std::boolalpha;
    std::cout << std::is_same<RemovePtr<int*>::type, int>::value << '\n';
    return 0;
}

Combinando Padrões

Você pode combinar padrões, por exemplo, fazendo a correspondência de um ponteiro para um valor constante, para tratar estruturas de tipos em camadas.

#include <iostream>

template <typename T>
struct Desc { static const char* k() { return "plain"; } };

template <typename T>
struct Desc<const T*> { static const char* k() { return "ptr to const"; } };

int main() {
    std::cout << Desc<int>::k() << '\n';
    std::cout << Desc<const int*>::k() << '\n';
    return 0;
}

Um Traço Prático de Contêiner

Use uma especialização parcial para extrair o tipo de elemento de um modelo semelhante a um contêiner.

#include <iostream>
#include <type_traits>

template <typename C>
struct Element { using type = void; };

template <template <typename> class C, typename T>
struct Element<C<T>> { using type = T; };

template <typename T>
struct Box { T item; };

int main() {
    std::cout << std::boolalpha;
    std::cout << std::is_same<Element<Box<int>>::type, int>::value << '\n';
    return 0;
}

Verificação Rápida

Teste sua compreensão da especialização parcial.

Recapitulação

Você aprendeu sobre especialização parcial:

personaliza um modelo de classe para um padrão de tipos, como T* ou const T
as funções usam sobrecarga, não especialização parcial
a versão correspondente mais especializada é escolhida
ela sustenta traços de tipos, como remove_pointer

Em seguida, você aprenderá SFINAE, uma forma de habilitar funções apenas quando um tipo atende aos requisitos.

Perguntas Frequentes

A aula “Especialização parcial” é grátis?

Sim — o texto completo de “Especialização parcial” é 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 “Especialização parcial”?

Especialize padrões de templates 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 “Especialização parcial”?

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