0Pricing
C++ Academy · Aula

Usar conceitos em modelos e auto

Restrinja modelos de funções e modelos de funções abreviados com conceitos

Usar conceitos em modelos e auto é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 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.

Recapitulação das três sintaxes

Você pode aplicar um conceito de três formas: como prefixo de um parâmetro de modelo, como uma cláusula requires ou com a sintaxe abreviada de modelo de função.

Sintaxe de prefixo

Substitua typename pelo nome do conceito.

template <std::integral T>
T add(T a, T b) { return a + b; }

Sintaxe da cláusula requires

Adicione requires depois da lista de parâmetros do modelo. É a mais flexível — oferece suporte a condições complexas.

template <typename T>
    requires std::integral<T> || std::floating_point<T>
T add(T a, T b) { return a + b; }

Cláusula requires posterior

Coloque requires depois da assinatura da função — útil em funções-membro quando a restrição depende dos parâmetros.

template <typename T>
class Container {
public:
    void sort() requires std::sortable<T> { /* ... */ }
};

Modelos de função abreviados

Use auto nos parâmetros e imponha restrições a ele. O compilador sintetiza o modelo internamente.

void greet(std::convertible_to<std::string> auto name) {
    std::cout << "Hello " << name;
}

Múltiplos parâmetros auto

Cada auto pode ter seu próprio conceito. Cada auto cria um parâmetro de modelo independente.

auto multiply(std::integral auto a, std::integral auto b) {
    return a * b;
}

Conceitos com modelos de classe

As mesmas três sintaxes se aplicam.

template <std::movable T>
class Buffer { /* ... */ };

template <typename T>
    requires std::default_initializable<T>
class Storage { /* ... */ };

Lambdas com restrições (C++20)

Lambdas podem ter parâmetros de modelo explícitos com conceitos.

auto print = []<std::integral T>(T x) {
    std::cout << x << " is integral";
};
print(42);

Resolução de sobrecarga baseada em conceitos

O compilador escolhe a sobrecarga mais restrita que corresponde. Conceitos mais específicos prevalecem sobre os menos específicos.

void process(std::integral auto x)       { std::cout << "int\n"; }
void process(std::signed_integral auto x) { std::cout << "signed\n"; }

process(42);    // calls signed_integral version

Funções-membro com restrições

Os membros de um modelo de classe podem ter suas próprias restrições.

template <typename T>
class Optional {
    T value_;
public:
    void clear() requires std::is_trivially_destructible_v<T> { /* fast */ }
    void clear() { /* general */ }
};

Tipos com restrições inicializados por padrão

Combine requires com valores padrão para escrever modelos claros, que revelem a intenção.

Guia de estilo

Use a sintaxe de prefixo no caso comum. Mude para requires quando as restrições forem complexas ou envolverem vários tipos. Use modelos de função abreviados para funções curtas e focadas.

Verificação rápida

Qual é a sintaxe abreviada de modelo de função para "uma função que aceita qualquer valor inteiro"?

Recapitulação

Aplique conceitos como prefixos, em cláusulas requires ou em modelos de função abreviados. A sobrecarga correspondente com mais restrições vence. Use a sintaxe mais clara para cada caso — prefixo para situações simples, requires para situações complexas e a forma abreviada para funções curtas.

Perguntas Frequentes

A aula “Usar conceitos em modelos e auto” é grátis?

Sim — o texto completo de “Usar conceitos em modelos e auto” é 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 “Usar conceitos em modelos e auto”?

Restrinja modelos de funções e modelos de funções abreviados com conceitos 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 3 de 4.

Quanto tempo leva a aula “Usar conceitos em modelos e auto”?

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

  1. Por que conceitos em vez de SFINAE
  2. Definir conceitos com requires
  3. Usar conceitos em modelos e auto
  4. Conceitos padrão comuns: integral e intervalos
← Voltar para C++ Academy