Última atualização：2026-10-12

Concepts (conceitos) no C++20¶

O C++20 introduziu os concepts (conceitos), que são um conjunto de restrições sobre parâmetros de template (avaliadas em tempo de compilação). Você pode usá-los em templates de classe e de função para controlar sobrecarga e especialização. Algumas vantagens incluem:

Impor restrições de tipo aos parâmetros de template
Melhorar a legibilidade do código (substituindo códigos SFINAE longos)
Fornecer mensagens de erro mais amigáveis
Evitar instanciações acidentais de templates ao restringir os tipos que podem ser usados

Tomemos como exemplo uma adição bem simples.

#include <iostream>

struct Foo {};

template <typename T>
T Add(T a, T b) {
  return a + b;
}

int main() {
  std::cout << Add(1, 2) << std::endl;
  Foo f1, f2;
  std::cout << Add(f1, f2) << std::endl;
  return 0;
}

Para Foo, não há suporte à adição e, ao mesmo tempo, tampouco é possível fazer std::cout << diretamente; portanto, a compilação gera uma enxurrada de erros envolvendo operator<< e operator+, mas essas não são as mensagens de erro que esperamos. O que gostaríamos é que o compilador nos desse a informação mais direta possível, ou seja: essa estrutura pode ou não ser somada?

add.cc: In function 'int main()':
add.cc:13:13: error: no match for 'operator<<' (operand types are 'std::ostream' {aka 'std::basic_ostream<char>'} and 'Foo')
   13 |   std::cout << Add(f1, f2) << std::endl;
      |   ~~~~~~~~~ ^~ ~~~~~~~~~~~
      |        |          |
      |        |          Foo
      |        std::ostream {aka std::basic_ostream<char>}
In file included from /usr/local/Cellar/gcc/13.2.0/include/c++/13/iostream:41,
                 from add.cc:1:
/usr/local/Cellar/gcc/13.2.0/include/c++/13/ostream:110:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(__ostream_type& (*)(__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  110 |       operator<<(__ostream_type& (*__pf)(__ostream_type&))

/usr/local/Cellar/gcc/13.2.0/include/c++/13/ostream:801:5: note:   template argument deduction/substitution failed:
/usr/local/Cellar/gcc/13.2.0/include/c++/13/ostream: In substitution of 'template<class _Ostream, class _Tp> _Ostream&& std::operator<<(_Ostream&&, const _Tp&) [with _Ostream = std::basic_ostream<char>&; _Tp = Foo]':
add.cc:13:26:   required from here
/usr/local/Cellar/gcc/13.2.0/include/c++/13/ostream:801:5: error: no type named 'type' in 'struct std::enable_if<false, void>'
add.cc: In instantiation of 'T Add(T, T) [with T = Foo]':
add.cc:13:19:   required from here
add.cc:7:12: error: no match for 'operator+' (operand types are 'Foo' and 'Foo')
    7 |   return a + b;
      |          ~~^~~

Quando usamos concept na implementação:

template <typename T>
concept Addable = requires(T a, T b) { a + b; };

template <typename T>
  requires Addable<T>
T Add(T a, T b) {
  return a + b;
}

obtemos exatamente o erro de compilação que nos interessa:

add_concept.cc: In function 'int main()':
add_concept.cc:17:19: error: no matching function for call to 'Add(Foo&, Foo&)'
   17 |   std::cout << Add(f1, f2) << std::endl;
      |                ~~~^~~~~~~~
add_concept.cc:10:3: note: candidate: 'template<class T>  requires  Addable<T> T Add(T, T)'
   10 | T Add(T a, T b) {
      |   ^~~
add_concept.cc:10:3: note:   template argument deduction/substitution failed:
add_concept.cc:10:3: note: constraints not satisfied
add_concept.cc: In substitution of 'template<class T>  requires  Addable<T> T Add(T, T) [with T = Foo]':
add_concept.cc:17:19:   required from here
add_concept.cc:6:9:   required for the satisfaction of 'Addable<T>' [with T = Foo]
add_concept.cc:6:19:   in requirements with 'T a', 'T b' [with T = Foo]
add_concept.cc:6:42: note: the required expression '(a + b)' is invalid
    6 | concept Addable = requires(T a, T b) { a + b; };
      |                                        ~~^~~

A seguir, vamos estudar em profundidade a sintaxe de concept com base nesse exemplo.

1.Sintaxe de concept¶

Sintaxe:

template <template-parameter-list>
concept concept-name = constraint-expression;

Comparemos com um exemplo real: Addable é o concept-name, e a constraint-expression é requires(T a, T b) { a + b; }.

template <typename T>
concept Addable = requires(T a, T b) { a + b; };

A forma de uso é:

#include <concepts>

Esse concept pode ser colocado em vários lugares, conforme segue:

a posição de typename
depois de requires
antes de auto

1.1 Substituir typename¶

Restringe o parâmetro de template, substituindo typename.

// template <typename T>  typename->Addable
template <Addable T>
T Add(T a, T b) {
  return a + b;
}

1.2 A palavra-chave requires¶

Usamos a palavra-chave requires em templates de função. Ela consegue verificar se o nosso template T é somável; se o template puder tratar a adição, ela retornará true.

O requires pode ficar dentro do template ou depois da função, mas não pode vir depois da classe. Ao mesmo tempo, ele tem duas formas de escrita:

requires como condição

Por exemplo:

template <typename T>
  requires Addable<T>
T Add(T a, T b) { ... }

requires como expressão

Por exemplo:

template <typename T>
concept Addable = requires(T a, T b) { a + b; };

1.2.1 Dentro do template¶

Função:

template <typename T>
  requires Addable<T>
T Add(T a, T b) {
  return a + b;
}

Classe:

template <typename T>
    requires Addable<T> 
class Bar {
 public:
  T Add(T a, T b) { return a + b; }
};

1.2.2 Cláusula requires à direita da função¶

Função:

template <typename T>
T Add(T a, T b)
  requires Addable<T>
{
  return a + b;
}

Para classes, essa forma de escrita não é suportada, gerando o erro: error: expected unqualified-id before 'requires' 28 | requires Addable

template <typename T>
class Bar requires Addable<T> 
{
 public:
  T Add(T a, T b) { return a + b; }
};

1.2.3 Exemplo básico de requires¶

Tomando como exemplo os tipos em um banco de dados: um banco de dados possui tipos diferentes, que classificamos em null, binary, number, etc.; queremos executar uma operação de impressão sobre os tipos passados e, por isso, temos o exemplo a seguir:

#include <concepts>

class NumberType {};
class BaseBinaryType {};
class NullType {};
class FloatingPointType : public NumberType {};
class IntegerType : public NumberType {};
class BinaryType: public BaseBinaryType {};

template <typename T>
  requires std::is_base_of_v<NumberType, T> || std::is_base_of_v<BaseBinaryType, T>
void PrintValue(T v) {}

int main() {
  PrintValue(FloatingPointType{});
  PrintValue(NullType{});
  return 0;
}

Para o requires, podemos usar ||; no exemplo acima aparece NullType, que não satisfaz o requires; portanto, a compilação produz:

concept_requires.cc:16:13: error: no matching function for call to 'PrintValue(NullType)'
   16 |   PrintValue(NullType{});
      |   ~~~~~~~~~~^~~~~~~~~~~~
concept_requires.cc:12:6: note: candidate: 'template<class T>  requires (is_base_of_v<NumberType, T>) || (is_base_of_v<BaseBinaryType, T>) void PrintValue(T)'
   12 | void PrintValue(T v) {}
      |      ^~~~~~~~~~
concept_requires.cc:12:6: note:   template argument deduction/substitution failed:
concept_requires.cc:12:6: note: constraints not satisfied
concept_requires.cc: In substitution of 'template<class T>  requires (is_base_of_v<NumberType, T>) || (is_base_of_v<BaseBinaryType, T>) void PrintValue(T) [with T = NullType]':
concept_requires.cc:16:13:   required from here
concept_requires.cc:12:6:   required by the constraints of 'template<class T>  requires (is_base_of_v<NumberType, T>) || (is_base_of_v<BaseBinaryType, T>) void PrintValue(T)'
concept_requires.cc:11:45: note: no operand of the disjunction is satisfied
   11 |   requires std::is_base_of_v<NumberType, T> || std::is_base_of_v<BaseBinaryType, T>
      |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

1.3 concept e auto¶

Quando entra o auto, podemos usá-lo junto com concept; por exemplo:

auto add(auto x, auto y) {
  return x + y;
}

Podemos transformar em:

template <typename T>
concept Addable = requires(T a, T b) { a + b; };

auto add2(Addable auto x, Addable auto y) {
  return x + y;
}

Na compilação, aparecerá:

concept_auto.cc:17:20: error: no matching function for call to 'add2(Foo&, Foo&)'
   17 |   std::cout << add2(f1, f2) << std::endl;
      |                ~~~~^~~~~~~~
concept_auto.cc:10:6: note: candidate: 'template<class auto:18, class auto:19>  requires (Addable<auto:18>) && (Addable<auto:19>) auto add2(auto:18, auto:19)'
   10 | auto add2(Addable auto x, Addable auto y) {
      |      ^~~~
concept_auto.cc:10:6: note:   template argument deduction/substitution failed:
concept_auto.cc:10:6: note: constraints not satisfied
concept_auto.cc: In substitution of 'template<class auto:18, class auto:19>  requires (Addable<auto:18>) && (Addable<auto:19>) auto add2(auto:18, auto:19) [with auto:18 = Foo; auto:19 = Foo]':
concept_auto.cc:17:20:   required from here
concept_auto.cc:8:9:   required for the satisfaction of 'Addable<auto:18>' [with auto:18 = Foo]
concept_auto.cc:8:19:   in requirements with 'T a', 'T b' [with T = Foo]
concept_auto.cc:8:42: note: the required expression '(a + b)' is invalid
    8 | concept Addable = requires(T a, T b) { a + b; };

2.Suporte dos compiladores¶

Requer GCC (10.0+), Clang (10.0+), com a opção de compilação: -std=c++20/-std=c++2a

https://en.cppreference.com/w/cpp/compiler_support

3.Resumo¶

Com os concepts fornecidos a partir do C++20, não precisamos mais dos mecanismos enable_if/SFINAE nem de sobrecargas de funções para fazer verificações de restrições de templates; o concept resolve essa tarefa para você, oferecendo um mecanismo de restrição de parâmetros de template mais claro e poderoso, que torna o código de templates mais fácil de escrever, entender e manter. Ao realizar verificação de tipos em tempo de compilação, ele ajuda a melhorar a robustez e a legibilidade do código.