Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

requires — contraintes et vérification des exigences

Le mot-clé requires introduit soit une clause qui contraint une déclaration, soit une expression qui vérifie des exigences portant sur des types et des opérations. Distinguer ces usages permet d’écrire des modèles dont la disponibilité dépend des capacités du type fourni.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

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 a deux usages principaux. Une clause requires spécifie la contrainte d’une déclaration : elle peut suivre la liste des paramètres du modèle ou apparaître comme clause finale d’une fonction. Les contraintes non satisfaites excluent une fonction de l’ensemble des candidats viables lors de la résolution de surcharge ; elles ne sélectionnent pas une branche à l’exécution.

Une expression requires, requires (T x) { ... }, produit une valeur de type bool ; sa liste de paramètres est facultative. Les paramètres locaux servent uniquement à décrire les exigences : ils ne créent pas d’objets. Dans requires requires (T x) { x + x; }, le premier requires commence une clause et le second une expression.

Il existe quatre types d’exigences entre les accolades : une exigence simple x + x; vérifie la validité d’une expression ; une exigence de type typename T::value_type; vérifie un nom de type ; une exigence composée { x + x } noexcept -> ResultConcept; vérifie que l’expression est valide, qu’elle n’est pas classée comme susceptible de lever une exception et que decltype((x + x)) satisfait le concept ; une exigence imbriquée requires Constraint<T>; exige qu’une contrainte soit satisfaite. noexcept et -> ResultConcept sont tous deux facultatifs. La vérification noexcept porte sur la classification de l’expression selon les règles du langage, et non sur la possibilité qu’une exception soit effectivement levée à l’exécution. Un opérateur surchargé déclaré noexcept peut lever une exception dans son corps ; si une exception s’échappe de l’opérateur, std::terminate est appelée. Les opérandes des exigences simples et composées ne sont pas évalués ; x == x; seul n’exige pas un résultat true.

Un échec de substitution dans le contexte immédiat des exigences d’un modèle peut produire false plutôt qu’une erreur de compilation. Ce n’est pas un mécanisme général de suppression des erreurs : une exigence invalide en dehors de la déclaration d’une entité modèle rend le programme mal formé. Si la substitution des arguments du modèle dans une exigence devait toujours entraîner un échec de substitution, le programme est mal formé sans qu’un diagnostic soit requis. Une exigence non satisfaite ne constitue pas en soi un échec de substitution : une exigence imbriquée requires false; peut faire en sorte qu’une expression requires donne false pour toute substitution, sans rendre le programme mal formé.

Dans l’exemple, le concept Addable contient une expression requires, tandis que add comporte une clause requires Addable<T>. Les vérifications static_assert portent sur un type pris en charge, un type non pris en charge et le résultat de l’addition. Cette entrée concerne C++23 ; le document fourni est un projet de travail évolutif, et non une publication C++23 figée.

Exemples

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

Résultat

5

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources