CKTIS / C++
Template e concept: parametro di template vincolato
I template descrivono famiglie di funzioni o tipi, mentre i concept stabiliscono requisiti per gli argomenti dei template. La dichiarazione template<Integer T> introduce un parametro di tipo T vincolato da Integer<T>, verificato durante la compilazione e non a runtime.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
template<typename T> concept C = /* bool constraint expression */;
template<C T> T identity(T value) { return value; }
// Alternative constraint placement:
// template<typename T> requires C<T>
// T identity(T value) { return value; }Un template descrive una famiglia di funzioni o tipi invece di una singola funzione o di un singolo tipo concreto. Un concept è un template che definisce vincoli sui propri argomenti. Nell’esempio, Integer è un requisito con nome basato su std::integral<T>: accetta i tipi interi, incluso bool, ma non double. Un concept si definisce a livello di namespace, non all’interno di una funzione.
Un parametro di template vincolato (constrained template parameter) in template<Integer T> è comunque un parametro di tipo, non un oggetto né una classe base. Questa sintassi introduce il vincolo Integer<T>. Per la funzione mostrata, template<typename T> requires Integer<T> esprime lo stesso requisito. Sono forme di dichiarazione alternative, non due definizioni da incollare insieme. Un semplice template<typename T> non impone questo vincolo.
Una clausola requires associa un vincolo a una dichiarazione. Un’espressione requires, per esempio requires(T x) { x + x; }, è invece un’espressione di tipo bool che verifica la validità dei requisiti scritti; non esegue x + x. Può essere usata nella definizione di un concept. Un concept non è una convalida dei dati a runtime né una prova che l’intero corpo della funzione sia valido: soddisfare i vincoli non esclude altri errori di compilazione.
Nell’esempio, identity(42) deduce T come int e restituisce 42. Decommentando identity(3.5), il vincolo non è soddisfatto, quindi questo overload non è un candidato valido; in assenza di un altro overload corrispondente, la chiamata è un errore. L’esempio è pensato per la compilazione come C++23. Il riferimento fornito è una bozza di lavoro in evoluzione, non una pubblicazione C++23 congelata; l’esempio non usa estensioni più recenti.
Esempi
#include <concepts>
#include <iostream>
template<typename T>
concept Integer = std::integral<T>;
template<Integer T>
constexpr T identity(T value) {
return value;
}
static_assert(Integer<int>);
static_assert(!Integer<double>);
static_assert(identity(42) == 42);
int main() {
std::cout << identity(42) << '\n';
// identity(3.5);
}
Risultato
42
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.