CKTIS / C++
requires — restricciones y comprobación de requisitos
La palabra clave requires introduce una cláusula que restringe una declaración o una expresión que comprueba requisitos sobre tipos y operaciones. Distinguir estos usos ayuda a escribir plantillas cuya disponibilidad depende de las capacidades del tipo proporcionado.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
template<class T> requires Constraint<T> void f(T);
template<class T> void f(T) requires Constraint<T>;
requires (T x) { x + x; typename T::value_type; { x + x } noexcept -> ResultConcept; requires Constraint<T>; }requires tiene dos usos principales. Una cláusula requires especifica la restricción de una declaración: puede ir después de la lista de parámetros de plantilla o aparecer como cláusula final de una función. Las restricciones no satisfechas excluyen una función de los candidatos viables durante la resolución de sobrecargas; no seleccionan una rama en tiempo de ejecución.
Una expresión requires, requires (T x) { ... }, produce un valor de tipo bool; su lista de parámetros es opcional. Los parámetros locales sirven únicamente para expresar requisitos: no crean objetos. En requires requires (T x) { x + x; }, el primer requires inicia una cláusula y el segundo una expresión.
Dentro de las llaves hay cuatro tipos de requisitos: un requisito simple x + x; comprueba si una expresión es válida; un requisito de tipo typename T::value_type; comprueba un nombre de tipo; un requisito compuesto { x + x } noexcept -> ResultConcept; comprueba que la expresión sea válida, que no se clasifique como susceptible de lanzar una excepción y que decltype((x + x)) satisfaga el concepto; un requisito anidado requires Constraint<T>; exige que se satisfaga una restricción. Tanto noexcept como -> ResultConcept son opcionales. La comprobación con noexcept se basa en cómo clasifican la expresión las reglas del lenguaje, no en si realmente se puede lanzar una excepción durante la ejecución. Un operador sobrecargado declarado noexcept puede lanzar una excepción dentro de su cuerpo; si una excepción se propaga fuera del operador, se llama a std::terminate. Los operandos de los requisitos simples y compuestos no se evalúan; x == x; por sí solo no exige un resultado true.
Un fallo de sustitución en el contexto inmediato de los requisitos de una plantilla puede producir false en lugar de un error de compilación. No es un mecanismo general para suprimir errores: un requisito no válido fuera de la declaración de una entidad de plantilla hace que el programa esté mal formado. Si la sustitución de los argumentos de plantilla en un requisito diera lugar siempre a un fallo de sustitución, el programa está mal formado y no se requiere diagnóstico. Que un requisito no se satisfaga no constituye por sí solo un fallo de sustitución: un requisito anidado requires false; puede hacer que una expresión requires dé false para cualquier sustitución sin que el programa esté mal formado.
En el ejemplo, el concepto Addable contiene una expresión requires, mientras que add tiene una cláusula requires Addable<T>. Las comprobaciones static_assert incluyen un tipo compatible, uno no compatible y el resultado de la suma. Esta entrada se refiere a C++23; el documento proporcionado es un borrador de trabajo en evolución, no una publicación definitiva de C++23.
Ejemplos
#include <iostream>
template<class T>
concept Addable = requires(T a, T b) {
a + b;
};
template<class T>
requires Addable<T>
constexpr auto add(T a, T b) {
return a + b;
}
struct NoAdd {};
static_assert(Addable<int>);
static_assert(!Addable<NoAdd>);
static_assert(add(2, 3) == 5);
int main() {
std::cout << add(2, 3) << '\n';
}
Resultado
5
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.