KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Templates en concepten: begrensde templateparameter

Templates beschrijven families van functies of typen, terwijl concepten eisen aan templateargumenten vastleggen. De declaratie template<Integer T> introduceert een typeparameter T die door Integer<T> wordt begrensd en tijdens het compileren wordt gecontroleerd, niet tijdens runtime.

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

Syntax

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

Een template beschrijft een familie van functies of typen in plaats van één concrete functie of één concreet type. Een concept is een template dat beperkingen voor zijn argumenten definieert. In het voorbeeld is Integer een benoemde eis op basis van std::integral<T>: deze accepteert integrale typen, waaronder bool, maar geen double. Definieer een concept op naamruimteniveau, niet binnen een functie.

Een begrensde templateparameter (constrained template parameter) in template<Integer T> is nog steeds een typeparameter, geen object of basisklasse. Deze syntaxis introduceert de beperking Integer<T>. Voor de getoonde functie drukt template<typename T> requires Integer<T> dezelfde eis uit. Dit zijn alternatieve declaratievormen, geen twee definities die samen moeten worden ingevoegd. Een gewone template<typename T> legt deze beperking niet op.

Een requires-clausule koppelt een beperking aan een declaratie. Een requires-expressie, zoals requires(T x) { x + x; }, is daarentegen een bool-expressie die controleert of de opgeschreven eisen geldig zijn; ze voert x + x niet uit. Zo’n expressie kan in een conceptdefinitie worden gebruikt. Een concept is geen runtimevalidatie van gegevens en bewijst ook niet dat de volledige functiebody geldig is: het voldoen aan de beperkingen sluit andere compilatiefouten niet uit.

In het voorbeeld leidt identity(42) T af als int en geeft 42 terug. Als identity(3.5) uit commentaar wordt gehaald, is niet aan de beperking voldaan en is deze overload dus geen geschikte kandidaat; zonder een andere overeenkomende overload is de aanroep een fout. Het voorbeeld is bedoeld voor compilatie als C++23. De aangeleverde referentie is een voortdurend bijgewerkt werkdocument, geen vastgelegde C++23-publicatie; het voorbeeld gebruikt geen nieuwere uitbreidingen.

Voorbeelden

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

Resultaat

42

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