Что действительно обрабатывает по шаблону <неподписанный интервал N> средний?

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

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

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

Шаблонный параметр типа:

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

Вы templatize Ваш класс на основе 'неподписанного интервала'

Пример:

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

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

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

Разница в том, что параметры имеют «типы», а переданные значения проверяются во время компиляции, как параметры для функций. Допустимые типы - это ваши обычные типы 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;
}

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