KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Niet-type-templateparameters

Een niet-type-templateparameter krijgt een waarde in plaats van een type. `std::size_t Size` legt de arraylengte vast; de compiler kan die uit functieargumenten afleiden.

Versie: ISO C++23; implementation support may vary

Syntax

template<class T, std::size_t Size> struct Buffer;

template<std::size_t Size>
using AoS = std::array<Row, Size>;

template<std::size_t Size>
void copy_rows(const AoS<Size>& source, AoS<Size>& destination);

template<auto Value> struct Tag;

In template<class T, std::size_t Size> krijgt T een type, terwijl Size een niet-type-templateparameter (NTTP) is en een waarde krijgt. Size is de parameternaam; 2 in AoS<2> is het templateargument. De lengte is onderdeel van het arraytype, dus AoS<2> en AoS<3> zijn verschillende typen.

Een expressie voor Size moet een geconverteerde constante expressie van het type std::size_t uit <cstddef> zijn. Je kunt de letterlijke waarde 2 gebruiken, of constexpr std::size_t n = 2; declareren en AoS<n> schrijven. Een lengte die tijdens de uitvoering wordt ingelezen voldoet niet aan die eis; gebruik in AoS<n> leidt tot een compilatiefout.

De declaratie using AoS = std::array<Row, Size>;, voorafgegaan door de templatekop, definieert een aliastemplate en geen nieuw type. In de functieparameters declareert & een lvalue-referentie; het vraagt geen adres op. const AoS<Size>& source verhindert dat je de bron via die referentie wijzigt, terwijl AoS<Size>& destination de functie het doelarray van de aanroeper laat wijzigen. Beide referenties zijn gebonden aan bestaande arrays; destination = source kopieert de elementen en bindt geen referentie opnieuw.

Sinds C++17 kan de compiler bij template<auto Value> het parametertype uit het argument afleiden. Dat argument moet nog steeds aan de NTTP-regels voldoen. Sinds C++20 zijn onder meer drijvendekommatypen en bepaalde letterlijke klassetypen toegestaan die aan de eisen voor een structureel type voldoen. Pointer- en referentieargumenten kennen eigen beperkingen: ze mogen bijvoorbeeld niet naar tijdelijke objecten of stringliterals wijzen of verwijzen. Dit artikel behandelt ISO C++23; de ondersteuning kan per implementatie verschillen.

Voorbeelden

#include <array>
#include <cstddef>
#include <iostream>

struct Row {
    int value;
};

template<std::size_t Size>
using AoS = std::array<Row, Size>;

template<std::size_t Size>
void copy_rows(const AoS<Size>& source, AoS<Size>& destination)
{
    destination = source;
}

int main()
{
    const AoS<2> source{Row{7}, Row{11}};
    AoS<2> destination{};
    copy_rows(source, destination);
    std::cout << destination[0].value << ' ' << destination[1].value << '\n';
}

Resultaat

7 11

`copy_rows(source, destination)` leidt `Size = 2` af uit de typen van beide arrays. `copy_rows<2>(source, destination)` geeft dezelfde waarde expliciet op. Als de arrays verschillende lengten hebben, compileert de aanroep zonder expliciet argument niet, omdat de afleiding tegenstrijdige waarden voor `Size` oplevert. Verwachte uitvoer: `7 11`.

Gerelateerde lessen

  • C++ · Les 21 · Gevorderd · Versie: 3

Bronnen