Última actualización：2026-10-12

Conceptos Concepts de C++20¶

C++20 introdujo los conceptos (concept), un conjunto de restricciones sobre los parámetros de plantilla (evaluados en tiempo de compilación). Puedes usarlos en plantillas de clase y de función para controlar la sobrecarga y la especialización de funciones. Algunas ventajas incluyen:

Obligar a que los parámetros de plantilla cumplan restricciones de tipo
Mejorar la legibilidad del código (sustituye los largos bloques SFINAE)
Proporcionar mensajes de error más amables
Prevenir instanciaciones accidentales de plantillas al restringir los tipos utilizables

Tomemos como ejemplo una suma bastante sencilla.

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

Foo no soporta la suma y, al mismo tiempo, tampoco se le puede aplicar directamente std::cout <<; por eso, en la compilación salta un montón de errores que incluyen operator<< y operator+, pero estos no son los mensajes de error que esperamos: lo que queremos es que el compilador nos dé el error más directo posible, es decir: ¿pueden sumarse estos structs o no?

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;
      |          ~~^~~

Cuando lo implementamos con concept:

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

Obtenemos así el error de compilación que nos interesa:

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 continuación, aprovechando el ejemplo anterior, adentrémonos en la sintaxis de los concept.

1.Sintaxis de concept¶

Sintaxis:

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

Comparemos con el ejemplo real: Addable es el concept-name, y constraint-expression es requires(T a, T b) { a + b; }.

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

Forma de usarlo:

#include <concepts>

Este concept puede colocarse en varios lugares, como se muestra:

El lugar de typename
Detrás de requires
Delante de auto

1.1 Sustituir typename¶

Restringe el parámetro de plantilla, sustituyendo a typename.

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

1.2 La palabra clave requires¶

Usamos la palabra clave requires en plantillas de función. Puede comprobar si nuestra plantilla T es o no sumable; si la plantilla puede manejar la suma, devolverá true.

requires puede colocarse en la plantilla o después de la función, pero no después de la clase. Además, tiene dos formas de escribirse:

requires con condición

Por ejemplo:

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

requires con expresión

Por ejemplo:

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

1.2.1 Colocarlo en la plantilla¶

Función:

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

Clase:

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

1.2.2 Cláusula requires final en la función¶

Función:

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

Para las clases esta forma no está soportada y dará un error: 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 Ejemplo básico de requires¶

Tomemos como ejemplo los tipos de una base de datos: en ella hay distintos tipos, que clasificamos en null, binary, number, etc.; queremos ejecutar una operación de impresión sobre el tipo pasado, y de ahí surge el siguiente ejemplo:

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

Con requires podemos usar ||; en el ejemplo anterior aparece NullType, que no satisface el requires, de modo que la compilación producirá:

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 y auto¶

Cuando aparece auto, podemos usarlo junto con concept; por ejemplo:

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

Podemos convertirlo en:

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

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

Al compilar 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.Soporte de los compiladores¶

Se necesita GCC (10.0+), Clang (10.0+), con la opción de compilación: -std=c++20/-std=c++2a

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

3.Resumen¶

Desde que C++20 proporciona concept, ya no necesitamos mecanismos como enable_if/SFINAE ni sobrecargas de funciones para hacer comprobaciones de restricciones de plantillas: concept resuelve esta operación por ti, ofreciendo un mecanismo de restricción de parámetros de plantilla más claro y potente, que hace el código de plantillas más fácil de escribir, entender y mantener. Al realizar la comprobación de tipos en tiempo de compilación, ayuda a mejorar la robustez y la legibilidad del código.