KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

requires — beperkingen en controle van vereisten

Het sleutelwoord requires introduceert een clausule die een declaratie beperkt, of een expressie die vereisten voor typen en bewerkingen controleert. Door deze toepassingen uit elkaar te houden, kun je templates schrijven waarvan de beschikbaarheid afhangt van de mogelijkheden van het opgegeven type.

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

Syntax

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 heeft twee belangrijke toepassingen. Een requires-clausule geeft de beperking van een declaratie aan: deze kan volgen op de lijst met templateparameters of als afsluitende clausule bij een functie staan. Niet-vervulde beperkingen sluiten een functie uit van de geschikte kandidaten bij overloadresolutie; ze kiezen geen runtimevertakking.

Een requires-expressie, requires (T x) { ... }, levert een waarde van het type bool op; de parameterlijst is optioneel. Lokale parameters zijn alleen notatie voor vereisten — ze maken geen objecten aan. In requires requires (T x) { x + x; } begint de eerste requires een clausule en de tweede een expressie.

Binnen de accolades zijn er vier soorten vereisten: een eenvoudig vereiste x + x; controleert of een expressie geldig is; een typevereiste typename T::value_type; controleert een typenaam; een samengesteld vereiste { x + x } noexcept -> ResultConcept; controleert of de expressie geldig is, of ze niet wordt aangemerkt als potentieel exception-werpend en of decltype((x + x)) aan het concept voldoet; een genest vereiste requires Constraint<T>; vereist dat aan een beperking wordt voldaan. Zowel noexcept als -> ResultConcept is optioneel. De noexcept-controle gaat uit van de classificatie volgens de taalregels, niet van de vraag of er tijdens de uitvoering daadwerkelijk een exception kan worden geworpen. Een overloaded operator die als noexcept is gedeclareerd, kan in zijn functiebody een exception werpen; als die exception buiten de operator terechtkomt, wordt std::terminate aangeroepen. Operanden van eenvoudige en samengestelde vereisten worden niet geëvalueerd; x == x; vereist op zichzelf geen resultaat true.

Een substitutiefout in de onmiddellijke context van de vereisten van een template kan false opleveren in plaats van een compilatiefout. Dit is geen algemeen mechanisme om fouten te onderdrukken: een ongeldig vereiste buiten de declaratie van een template-entiteit maakt het programma ongeldig. Als het invullen van templateargumenten in een vereiste altijd tot een substitutiefout zou leiden, is het programma ongeldig zonder dat een diagnose verplicht is. Dat niet aan een vereiste wordt voldaan, is op zichzelf geen substitutiefout: een genest vereiste requires false; kan ervoor zorgen dat een requires-expressie bij elke substitutie false oplevert zonder het programma ongeldig te maken.

In het voorbeeld bevat het concept Addable een requires-expressie, terwijl add een requires Addable<T>-clausule heeft. De static_assert-controles omvatten een ondersteund type, een niet-ondersteund type en het resultaat van de optelling. Dit artikel is gericht op C++23; het geleverde document is een veranderende werkdraft, geen definitieve C++23-publicatie.

Voorbeelden

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

Resultaat

5

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen