CKTIS / C++
requires — restrições e verificação de requisitos
A palavra-chave requires introduz uma cláusula que restringe uma declaração ou uma expressão que verifica requisitos relativos a tipos e operações. Distinguir estes usos ajuda a escrever modelos cuja disponibilidade depende das capacidades do tipo fornecido.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
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 tem duas utilizações principais. Uma cláusula requires especifica a restrição de uma declaração: pode surgir depois da lista de parâmetros do modelo ou como cláusula final de uma função. Restrições não satisfeitas excluem uma função dos candidatos viáveis durante a resolução de sobrecargas; não selecionam um ramo em tempo de execução.
Uma expressão requires, requires (T x) { ... }, produz um valor do tipo bool; a lista de parâmetros é opcional. Os parâmetros locais servem apenas para descrever requisitos — não criam objetos. Em requires requires (T x) { x + x; }, o primeiro requires inicia uma cláusula e o segundo inicia uma expressão.
Dentro das chavetas existem quatro tipos de requisitos: um requisito simples x + x; verifica a validade de uma expressão; um requisito de tipo typename T::value_type; verifica um nome de tipo; um requisito composto { x + x } noexcept -> ResultConcept; verifica se a expressão é válida, se não é classificada como suscetível de lançar uma exceção e se decltype((x + x)) satisfaz o conceito; um requisito aninhado requires Constraint<T>; exige que uma restrição seja satisfeita. Tanto noexcept como -> ResultConcept são opcionais. A verificação com noexcept incide sobre a classificação da expressão segundo as regras da linguagem, não sobre a possibilidade de ser efetivamente lançada uma exceção durante a execução. Um operador sobrecarregado declarado noexcept pode lançar uma exceção no seu corpo; se uma exceção se propagar para fora do operador, é invocada a função std::terminate. Os operandos dos requisitos simples e compostos não são avaliados; x == x;, por si só, não exige um resultado true.
Uma falha de substituição no contexto imediato dos requisitos de um modelo pode produzir false em vez de um erro de compilação. Não se trata de um mecanismo universal para suprimir erros: um requisito inválido fora da declaração de uma entidade de modelo torna o programa mal formado. Se a substituição dos argumentos do modelo num requisito resultasse sempre numa falha de substituição, o programa estaria mal formado sem que fosse exigido um diagnóstico. Um requisito não satisfeito não constitui, por si só, uma falha de substituição: um requisito aninhado requires false; pode fazer com que uma expressão requires produza false para qualquer substituição sem tornar o programa mal formado.
No exemplo, o conceito Addable contém uma expressão requires, enquanto add tem uma cláusula requires Addable<T>. As verificações static_assert abrangem um tipo suportado, um tipo não suportado e o resultado da adição. Esta entrada diz respeito a C++23; o documento fornecido é um projeto de trabalho em evolução, não uma publicação C++23 definitiva.
Exemplos
#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
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.