Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Paramètres de template non typés

Un paramètre de template non typé reçoit une valeur plutôt qu’un type. `std::size_t Size` fixe la taille du tableau, que le compilateur peut déduire des arguments de la fonction.

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

Syntaxe

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;

Dans template<class T, std::size_t Size>, T reçoit un type, tandis que Size est un paramètre de template non typé (NTTP) et reçoit une valeur. Size est le nom du paramètre ; 2 dans AoS<2> est l’argument de template. La taille fait partie du type du tableau : AoS<2> et AoS<3> sont des types distincts.

Une expression donnée pour Size doit être une expression constante convertie de type std::size_t, fourni par <cstddef>. On peut utiliser le littéral 2, ou déclarer constexpr std::size_t n = 2; et utiliser AoS<n>. Une taille lue sur l’entrée à l’exécution ne remplit pas cette condition ; son utilisation dans AoS<n> provoque une erreur de compilation.

La déclaration using AoS = std::array<Row, Size>;, précédée de l’en-tête de template, définit un alias de type paramétré et non un nouveau type. Dans les paramètres de la fonction, & déclare une référence lvalue ; il ne prend pas une adresse. const AoS<Size>& source interdit de modifier la source par cette référence, tandis que AoS<Size>& destination permet de modifier le tableau de destination de l’appelant. Les deux références se lient à des tableaux existants ; destination = source copie les éléments sans changer l’objet désigné par une référence.

Depuis C++17, template<auto Value> permet de déduire le type du paramètre à partir de l’argument, qui doit toujours respecter les règles des NTTP. Depuis C++20, les types admis comprennent les types flottants et certaines classes littérales qui remplissent les conditions d’un type structurel. Les arguments pointeurs et références ont leurs propres restrictions : ils ne peuvent notamment pas désigner un objet temporaire ou un littéral de chaîne. Cette fiche couvre ISO C++23 ; la prise en charge peut varier selon l’implémentation.

Exemples

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

Résultat

7 11

`copy_rows(source, destination)` déduit `Size = 2` à partir des types des deux tableaux. `copy_rows<2>(source, destination)` fournit explicitement la même valeur. Si les tailles diffèrent, l’appel sans argument explicite ne compile pas, car la déduction donne deux valeurs incompatibles pour `Size`. Sortie attendue : `7 11`.

Leçons associées

  • C++ · Leçon 21 · Avancé · Version : 3

Sources