Что означает шаблон <unsigned int N>?

Question

При объявлении шаблона я привык иметь такой код:

template <class T>

Но в этом вопросе они использовали:

template <unsigned int N>

Я проверил, что это компилируется. Но что это значит? Это не типовой параметр? И если так, как мы можем иметь шаблон без какого-либо параметра типа?

Answer 1

Да, это не типовой параметр. Вы можете иметь несколько видов параметров шаблона

• Параметры типа.
  • Типы
  • Шаблоны (только шаблоны классов и псевдонимов, без функций или шаблонов переменных)
• Нетипичные параметры
  • Pointers
  • Ссылки
  • Выражения из интегральных констант

То, что у вас есть, имеет последний вид. Это константа времени компиляции (так называемое константное выражение) и имеет тип integer или перечисление. Изучив его в стандарте, мне пришлось переместить шаблоны классов в раздел типов - даже если шаблоны не являются типами. Но они все же называются тип-параметрами для целей описания этих видов. Вы можете иметь указатели (а также указатели членов) и ссылки на объекты / функции, которые имеют внешнюю связь (те, на которые можно ссылаться из других объектных файлов и чей адрес уникален во всей программе). Примеры:

Параметр типа шаблона:

template<typename T>
struct Container {
    T t;
};

// pass type "long" as argument.
Container<long> test;

Целочисленный параметр шаблона:

template<unsigned int S>
struct Vector {
    unsigned char bytes[S];
};

// pass 3 as argument.
Vector<3> test;

Параметр указателя шаблона (передача указателя на функцию)

template<void (*F)()>
struct FunctionWrapper {
    static void call_it() { F(); }
};

// pass address of function do_it as argument.
void do_it() { }
FunctionWrapper<&do_it> test;

Ссылочный параметр шаблона (с передачей целого числа)

template<int &A>
struct SillyExample {
    static void do_it() { A = 10; }
};

// pass flag as argument
int flag;
SillyExample<flag> test;

Параметр шаблона шаблона.

template<template<typename T> class AllocatePolicy>
struct Pool {
    void allocate(size_t n) {
        int *p = AllocatePolicy<int>::allocate(n);
    }
};

// pass the template "allocator" as argument. 
template<typename T>
struct allocator { static T * allocate(size_t n) { return 0; } };
Pool<allocator> test;

Шаблон без каких-либо параметров невозможен. Но шаблон без какого-либо явного аргумента возможен - он имеет аргументы по умолчанию:

template<unsigned int SIZE = 3>
struct Vector {
    unsigned char buffer[SIZE];
};

Vector<> test;

Синтаксически template<> зарезервировано для обозначения явной специализации шаблона вместо шаблона без параметров:

template<>
struct Vector<3> {
    // alternative definition for SIZE == 3
};

Answer 2

Вполне возможно шаблонировать класс по целому числу, а не по типу. Мы можем присвоить шаблонное значение переменной или иным образом манипулировать им, как мы могли бы использовать любой другой целочисленный литерал:

unsigned int x = N;

Фактически, мы можем создать алгоритмы, которые оценивают во время компиляции (из Wikipedia ):

template <int N>
struct Factorial 
{
     enum { value = N * Factorial<N - 1>::value };
};

template <>
struct Factorial<0> 
{
    enum { value = 1 };
};

// Factorial<4>::value == 24
// Factorial<0>::value == 1
void foo()
{
    int x = Factorial<4>::value; // == 24
    int y = Factorial<0>::value; // == 1
}

Answer 3

Вы шаблонизируете свой класс на основе «unsigned int».

Пример:

template <unsigned int N>
class MyArray
{
    public:
    private:
        double    data[N]; // Use N as the size of the array
};

int main()
{
    MyArray<2>     a1;
    MyArray<2>     a2;

    MyArray<4>     b1;

    a1 = a2;  // OK The arrays are the same size.
    a1 = b1;  // FAIL because the size of the array is part of the
              //      template and thus the type, a1 and b1 are different types.
              //      Thus this is a COMPILE time failure.
 }

Answer 4

Шаблонный класс похож на макрос, только намного меньше зла.

Думайте о шаблоне как о макросе. Параметры в шаблоне подставляются в определение класса (или функции), когда вы определяете класс (или функцию) с помощью шаблона.

Разница в том, что параметры имеют "типы", и переданные значения проверяются во время компиляции, как параметры для функций. Допустимые типы - это ваши обычные типы C ++, такие как int и char. Когда вы создаете экземпляр класса шаблона, вы передаете значение указанного вами типа, и в новой копии определения класса шаблона это значение подставляется везде, где имя параметра было в исходном определении. Так же, как макрос.

Вы также можете использовать типы "class" или "typename" для параметров (они действительно одинаковы). С параметром одного из этих типов вы можете передать имя типа вместо значения. Как и раньше, везде имя параметра было в определении класса шаблона, как только вы создаете новый экземпляр, он становится любым типом, который вы передаете. Это наиболее распространенное использование для шаблона класса; Каждый, кто знает что-нибудь о шаблонах C ++, знает, как это сделать.

Рассмотрим пример кода этого шаблона:

#include <cstdio>
template <int I>
class foo
{
  void print()
  {
    printf("%i", I);
  }
};

int main()
{
  foo<26> f;
  f.print();
  return 0;
}

Функционально он такой же, как этот код, использующий макросы:

#include <cstdio>
#define MAKE_A_FOO(I) class foo_##I \
{ \
  void print() \
  { \
    printf("%i", I); \
  } \
};

MAKE_A_FOO(26)

int main()
{
  foo_26 f;
  f.print();
  return 0;
}

Конечно, версия шаблона в миллиард раз безопаснее и гибче.