Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

requires — vincoli e verifica dei requisiti

La parola chiave requires introduce una clausola che vincola una dichiarazione oppure un’espressione che verifica requisiti relativi a tipi e operazioni. Distinguere questi usi aiuta a scrivere template la cui disponibilità dipende dalle capacità del tipo fornito.

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

Sintassi

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 ha due usi principali. Una clausola requires specifica il vincolo di una dichiarazione: può seguire l’elenco dei parametri del template oppure comparire come clausola finale di una funzione. I vincoli non soddisfatti escludono una funzione dai candidati validi durante la risoluzione degli overload; non selezionano un ramo in fase di esecuzione.

Un’espressione requires, requires (T x) { ... }, produce un valore di tipo bool; il suo elenco di parametri è facoltativo. I parametri locali servono solo a esprimere i requisiti: non creano oggetti. In requires requires (T x) { x + x; }, il primo requires avvia una clausola e il secondo un’espressione.

Tra le parentesi graffe ci sono quattro tipi di requisiti: un requisito semplice x + x; verifica la validità di un’espressione; un requisito di tipo typename T::value_type; verifica un nome di tipo; un requisito composto { x + x } noexcept -> ResultConcept; verifica che l’espressione sia valida, che non sia classificata come potenzialmente in grado di lanciare un’eccezione e che decltype((x + x)) soddisfi il concept; un requisito annidato requires Constraint<T>; richiede che sia soddisfatto un vincolo. Sia noexcept sia -> ResultConcept sono facoltativi. La verifica con noexcept riguarda la classificazione dell’espressione secondo le regole del linguaggio, non la possibilità che durante l’esecuzione venga effettivamente lanciata un’eccezione. Un operatore sovraccaricato dichiarato noexcept può lanciare un’eccezione al proprio interno; se un’eccezione si propaga all’esterno dell’operatore, viene chiamata std::terminate. Gli operandi dei requisiti semplici e composti non vengono valutati; x == x; da solo non richiede un risultato true.

Un errore di sostituzione nel contesto immediato dei requisiti di un template può produrre false invece di un errore di compilazione. Non è un meccanismo universale per sopprimere gli errori: un requisito non valido al di fuori della dichiarazione di un’entità template rende il programma non valido. Se sostituire gli argomenti del template in un requisito causasse sempre un errore di sostituzione, il programma è mal formato e non è richiesta alcuna diagnostica. Un requisito non soddisfatto non costituisce di per sé un errore di sostituzione: un requisito annidato requires false; può far sì che un’espressione requires restituisca false per ogni sostituzione senza rendere il programma mal formato.

Nell’esempio, il concept Addable contiene un’espressione requires, mentre add ha una clausola requires Addable<T>. I controlli static_assert riguardano un tipo supportato, uno non supportato e il risultato dell’addizione. Questa voce riguarda C++23; il documento fornito è una bozza di lavoro in evoluzione, non una pubblicazione C++23 definitiva.

Esempi

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

Risultato

5

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti