Программирование. Принципы и практика использования C++ Исправленное издание

A.13.1. Шаблонные аргументы

Аргументы шаблонного класса указываются каждый раз, когда используется его имя.

 vector<int> v1; // OK
 vector v2; // ошибка: пропущен шаблонный аргумент
 vector<int,2> v3; // ошибка: слишком много шаблонных аргументов
 vector<2> v4; // ошибка: ожидается тип шаблонного аргумента

Аргументы шаблонной функции обычно выводятся из ее аргументов.

 template<class T>
 T find(vector<T>& v, int i)
 {
  return v[i];
 }

 vector<int> v1;
 vector<double> v2;
 // ...
int x1 = find(v1,2); // здесь тип T — это int
 int x2 = find(v2,2); // здесь тип T — это double

Можно объявить шаблонную функцию, для которой невозможно вывести ее шаблонные аргументы. В этом случае мы должны конкретизировать шаблонные аргументы явно (точно так же, как для шаблонных классов). Рассмотрим пример.

 template<class T, class U> T* make(const U& u) { return new T(u); }
 int* pi = make<int>(2);
 Node* pn = make<Node>(make_pair("hello",17));

Этот код работает, только если объект класса Node можно инициализировать объектом класса pair<const char*,int> (раздел Б.6.3). Из механизма явной конкретизации шаблонной функции можно исключать только замыкающие шаблонные аргументы (которые будут выведены).

A.13.2. Конкретизация шаблонов

Вариант шаблона для конкретного набора шаблонных аргументов называется специализацией (specialization). Процесс генерации специализаций на основе шаблона и набора аргументов называется конкретизацией шаблона (template instantiation). Как правило, эту задачу решает компилятор, но программист также может самостоятельно определить отдельную специализацию. Обычно это делается, когда общий шаблон для конкретного набора аргументов неприемлем. Рассмотрим пример.

 template<class T> struct Compare { // общее сравнение
  bool operator(const T& a,const T& b) const
  {
  return a<b;
  }
 };

 template<> struct Compare<const char*> { // сравнение C-строк
  bool operator(const char* a,const char* b) const
  {
  return strcmp(a,b)==0;
  }
 };

 Compare<int> c2; // общее сравнение
 Compare<const char*> c; // сравнение С-строк

 bool b1 = c2(1,2); // общее сравнение
 bool b2 = c("asd","dfg"); // сравнение С-строк

Аналогом специализации для функций является перегрузка.

 template<class T> bool compare(const T& a,const T& b)
 {
  return a<b;
 }

bool compare (const char* a, const char* b) // сравнение С-строк
 {
  return strcmp(a,b)==0;
 }

 bool b3 = compare(2,3); // общее сравнение
 bool b4 = compare("asd","dfg"); // сравнение С-строк

Отдельная компиляция шаблонов (когда в заголовочных файлах содержатся только объявления, а в исходных файлах — однозначные определения) не гарантирует переносимость программы, поэтому, если шаблон необходимо использовать в разных исходных файлах, в заголовочном файле следует дать его полное определение.

A.13.3. Шаблонные типы членов-классов

Шаблон может иметь как члены, являющиеся типами, так и члены, не являющиеся типами (как данные-члены и функции-члены). Это значит, что в принципе трудно сказать, относится ли имя члена к типу или нет. По техническим причинам, связанным с особенностями языка программирования, компилятор должен знать это, поэтому мы ему должны каким-то образом передать эту информацию. Для этого используется ключевое слово typename. Рассмотрим пример.

 template<class T> struct Vec {
  typedef T value_type; // имя члена
 static int count; // данное-член
  // ...
 };

 template<class T> void my_fct(Vec<T>& v)
 {
  int x = Vec<T>::count; // имена членов по умолчанию
  // считаются относящимися не к типу
  v.count = 7; // более простой способ сослаться
  // на член, не являющийся типом
  typename Vec<T>::value_type xx = x; // здесь нужно слово
  // "typename"
  // ...
 }

Более подробная информация о шаблонах приведена в главе 19.

A.14. Исключения

Исключения используются (посредством инструкции throw) для того, чтобы сообщить вызывающей функции об ошибке, которую невозможно обработать на месте. Например, спровоцируем исключение Bad_size в классе Vector.

 struct Bad_size {
  int sz;
  Bad_size(int s):ss(s) { }
 };

 class Vector {
  Vector(int s) { if (s<0 || maxsize<s) throw Bad_size(s); }
  // ...
 };

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