Вы можете создать прототип шаблона функции в виде его предварительного объявления. Такое объявление информирует компилятор о наличии шаблона, а также сообщает об ожидаемых параметрах. Например, прототип шаблона функции Sort будет выглядеть так:

template void Sort(T array, Tsize size);

Имена формальных параметров шаблона могут не совпадать в предварительном объявлении и определении шаблона. Так, например, в следующем фрагменте и прототип шаблона, и определение шаблона относятся к одной и той же функции:

template T max(T, T);

template

Type max(Type a, Type b)

if (a > b) return a; else return b;

Использование шаблона функции

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

Например, в следующем примере функция min() конкретизируется дважды: один раз типом int и один раз типом double:

template

Type min(Type a, Type b)

if (a < b) return a; else return b;

int x = 4, y = 5, z;

double t = 6.56, r = 3.07, p;

Специализация шаблонов функции

Специализированная функция шаблона – это обычная функция, имя которой совпадает с именем функции в шаблоне, но которая определяется для параметров специфических типов. Специализированные функции шаблона определяют в том случае, когда обобщенный шаблон не годится для некоторого типа данных. Например, функция шаблона min

template

Type min(Type a, Type b)

if (a < b) return a; else return b;

не может применяться для строк (для типа char*) , так как генерируемый компилятором код будет просто сравнивать их положение в памяти (адреса). Для корректного сравнения строк можно определить специализированную функцию:

char* min(char* s1, char* s2)

if (strcmp(s1,s2)>0) return s2; else return s1;

Тогда обращаться к такой функции можно так же, как и к функции шаблона:

int i1 = 3, i2 = 5;

cout << “max int = ” << max(i1, i2) << endl;

char* s1 = “Golden Eagle”;

char* s2 = “Perigrine Falcon”;

cout << “max str = “ << max(s1, s2) << endl;

Шаблоны классов

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

Синтаксис шаблона класса

template <<список аргументов шаблона>>

class <имя класса>

<тело класса>

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

Затем следует определение класса. Оно аналогично определению обычного класса, за исключением того, что использует список аргументов шаблона.

Параметры шаблона, состоящие из ключевого слова class и следующего за ним идентификатора, часто называют параметрами типа . Другими словами, они информируют компилятор, что шаблон предполагает тип в качестве аргумента.

Собрался я было писать текст про всякие крутые структуры данных и тут оказалось, что мы ещё не разбирали несколько очень важных возможностей C++. Шаблоны - одна из них.

Шаблоны (templates) - очень мощное средство. Шаблонные функции и классы позволяют очень сильно упростить программисту жизнь и сберечь огромное количество времени, сил и нервов. Если вам покажется, что шаблоны не сильно-то и значимая тема для изучения, знайте - вы заблуждаетесь.

Шаблонные функции

Простой пример шаблонной функции:

код на языке c++ Type square (Type a) { Type b; b = a*a; return b; } int x = 5; int i; i = square(5); float y = 0.5; float f; f = square(y);

Если бы мы создавали функции по старинке, то тогда бы пришлось писать две разные функции: для типа int и для типа float. А если бы понадобилась такая же функция, использующая другие типы, пришлось бы заново писать и её. Используя шаблоны, можно ограничиться только одним экземпляром функции, оставив всю грязную работу компилятору.

Вместо использования какого-то определённого типа, в функции используется параметрический тип (или по другому - аргумент шаблона). Здесь я обозвал параметрический тип идентификатором Type. В функции этот идентификатор встречается три раза: возвращаемое значение, аргумент функции и определение переменной s. То есть Type используется как любой обычный тип.

Но чтобы код заработал, перед функцией нужно добавить следующую строку (я показал несколько вариантов синтаксиса, все они рабочие):

код на языке c++ template Type square (Type a) template < class Type > Type square (Type a) template < class Type > Type square (Type a)

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

Идентификатор параметрического типа тоже может быть любым. Мы часто будем пользоваться вот такими: TypeA, TypeB, Datatype, T.

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

В шаблонах можно использовать несколько параметрических типов, и конечно же можно смешивать параметрические типы со стандартными (только нужно позаботиться о правильном приведении типов). Приведу пример в котором используется два параметрических типа TypeA, TypeB и базовый тип int:

код на языке c++ template TypeB example_function (TypeA a, TypeB b) { int x = 5; b = a + x; return b; }

Но шаблонные функции - не самое интересное, что мы сегодня рассмотрим.

Шаблонные классы

В общем-то шаблонные классы создаются почти так же как и шаблонные функции - перед именем класса записывается ключевое слово template. Шаблонные классы рассмотрим на примере стека:

код на языке c++ template class stack { private: int top; Type s; public: stack (): top(0) {} void push(Type var) { top++; s = var; } Type pop(); }; template Type stack::pop() { Type var = s; top--; return var; } Здесь мы опре

делили стек из десяти элементов. Эти элементы могут быть какого угодно типа, об этом чуть-чуть ниже.

Единственное на что хочу обратить ваше внимание: определение функций push и pop. Функция push определена внутри класса, а функция pop - снаружи. Для всех функции объявлённых за пределами класса, нужно обязательно указывать ключевое слово template. Выражение перед именем функции совпадает с тем, которое указывается перед именем класса.

Теперь посмотрим как работать с шаблонными классами:

код на языке c++ stack s1; stack s2; s1.push(3); s1.push(2); s1.pop(); s2.push(0.5);

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

У шаблонных классов есть одна потрясающая особенность - кроме стандартных типов, они могут работать и с пользовательскими. Рассмотрим небольшой пример. Для этого определим простой класс warrior:

код на языке c++ class warrior { public: int health; warrior () : health(0) {} }; stack s; warrior w1; warrior w2; warrior w3; s.push(w1); s.push(w3); s.pop(); s.push(w2);

Смотрите, теперь в стеках можно размещать переменные типа warrior!!! Возможно вы не поверите мне, но это очень круто! Насколько это круто, вы сможете убедиться когда на основе списков мы будем создавать графы и деревья.

По шаблонам пока всё. Позже разберём более сложные случаи использования шаблонных классов.

Функция-шаблон определяет общий набор операций, который будет применен к данным различ­ных типов. Используя этот механизм, можно применять некоторые общие алгоритмы к широко­му кругу данных. Как известно, многие алгоритмы логически одинаковы вне зависимости от типа данных, с которыми они оперируют. Например, алгоритм быстрой сортировки Quicksort один и тот же и для массива целых чисел, и для массива чисел с плавающей запятой. Отличается только тип данных, подлежащих сортировке. При помощи создания функции-шаблона (generic function) можно определить сущность алгоритма безотносительно к типу данных. После этого компилятор автоматически генерирует корректный код для того типа данных, для которого создается данная конкретная реализация функции на этапе компиляции. По существу, когда создается функция- шаблон, создается функция, которая может автоматически перегружать сама себя.

Функции-шаблоны создаются с использованием ключевого слова template (шаблон). Обычное значение слова «шаблон» достаточно полно отражает его использование в С++. Шаблон исполь­зуется для создания каркаса функции, оставляя компилятору реализацию подробностей. Общая форма функции-шаблона имеет следующий вид:

template возвращаемый_тип имя_функции(список параметров)
{
// тело функции
}

Здесь птип является параметром-типом, «держателем места» (placeholder) для имени типа дан­ных, которое используется функцией. Этот параметр-тип может быть использован в определении функции. Однако это только «держатель места», который будет автоматически заменен компи­лятором на фактический тип данных во время создания конкретной версии функции.

Ниже приведен короткий пример, в котором создается функция-шаблон, имеющая два пара­метра. Эта функция меняет между собой величины значений этих параметров. Поскольку общий процесс обмена значениями между двумя переменными не зависит от их типа, то он естествен­ным способом может быть реализован с помощью функции-шаблона.

// пример шаблона функции
#include
// шаблон функции
template void swap(X &a, X &b)
{
X temp;
temp = a;
a = b;
b = temp;
}
int main()
{
int i=10, j = 20;
float x=10.1, у= 23.3;
char a="x", b="z";
cout << "Original i, j: " << i << " " << j << endl;
cout << "Original x, y: " << x << " " << у << endl;
cout << "Original a, b: " << a << " " << b << endl;
swap(i, j); // обмен целых
swap(x, у); // обмен вещественных значений
swap(a, b); // обмен символов
cout << "Swapped i, j: " << i << " " << j << endl;
cout << "Swapped x, y: " << x << " " << у << endl;
cout << "Swapped a, b: " << a << " " << b << endl;
return 0;
}

Рассмотрим эту программу более внимательно. Строка

Template void swap (X &а, X &b)

Указывает компилятору, что создается шаблон. Здесь X - шаблон типа, используемый в качестве параметра-типа. Далее следует объявление функции swap() с использованием типа данных X для тех параметров, которые будут обмениваться значениями. В функции main() функция swap() вы­зывается с передачей ей данных трех различных типов: целых чисел, чисел с плавающей запятой и символов. Поскольку функция swap() является функцией-шаблоном, то компилятор автоматичес­ки создаст три разные версии функции swap() - одну для работы с целыми числами, другую для работы с числами с плавающей запятой и, наконец, третью для работы с переменными символь­ного типа.

Трюки со специализацией шаблонов C++

• C++

Специализация шаблонов является одной из «сложных» фичей языка с++ и использутся в основном при создании библиотек. К сожалению, некоторые особенности специализации шаблонов не очень хорошо раскрыты в популярных книгах по этому языку. Более того, даже 53 страницы официального ISO стандарта языка, посвященные шаблонам, описывают интересные детали сумбурно, оставляя многое на «догадайтесь сами - это же очевидно». Под катом я постарался ясно изложить базовые принципы специализации шаблонов и показать как эти принципы можно использовать в построении магических заклинаний.

Hello World

Template<> class A< int > {}; // здесь int - это аргумент шаблона
Готово, можно писать методы и поля специальной реализации для int. Такая специализация обычно называется полной (full specialization или explicit specialization). Для большинства практических задач большего не требуется. А если требуется, то…

Специализированный шаблон - это новый шаблон

Специализированный шаблон может иметь свои параметры шаблона

Template< typename S, typename U > class A< int > {};
Правда, именно такой код компилятор не скомпилирует - новые параметры шаблона S и U мы никак не используем, что для специализированного шаблонного класса запрещено (а то что это класс специализированный компилятор понимает потому, что у него такое же имя "A" как у уже объявленного шаблонного класса). Компилятор даже специальную ошибку скажет: «explicit specialization is using partial specialization syntax, use template<> instead». Намекает, что если сказать нечего - то надо использовать template<> и не выпендриваться. Тогда для чего же в специализированном шаблонном классе можно использовать новые параметры? Ответ странный - для того, чтобы задать аргументы специализации (аргументы - это то, что после имени класса в угловых скобках). То есть специализируя шаблонный класс мы можем вместо простого и понятного int специализировать его через новые параметры :

Template< typename S, typename U > class A< std::map< S, U > > {};
Такая странная запись скомпилируется. И при использовании получившегося шаблонного класса с std::map будет использована специализация, где тип ключа std::map будет доступен как параметр нового шаблона S, а тип значения std::map как U.

Такая специализация шаблона, при которой задается новый список параметров и через эти параметры задаются аргументы для специализации называется частичной специализацией (partial specialization). Почему «частичной»? Видимо потому, что изначально задумывалась как синтаксис для специализации шаблона не по всем аргументам. Пример, где шаблонный класс с двумя параметрами специализируется только по одному из них (специализация будет работать когда первый аргумент, T, будет указан как int. При этом второй аргумент может быть любым - для этого в частичной специализации введен новый параметр U и указан в списке аргументов для специализации):

Template< typename T, typename S > class B {}; template< typename U > class B< int, U > {};

Магические последствия частичной специализации

Template< typename S, typename U > class A< S(*)(U) > {};
А если в специализированном шаблоне объявить typedef или static const int (пользуясь тем, что это новый шаблон), то можно использовать его для извлечения нужной информации из типа. Например, мы используем шаблонный класс для хранения объектов и хотим получить размер переданного объекта или 0, если это указатель. В две строчки:

Template< typename T > struct Get { const static int Size = sizeof(T); }; template< typename S > struct Get< S* > { const static int Size = 0; }; Get< int >::Size // например, 4 Get< int* >::Size // 0 - нашли указатель:)
Магия этого типа используется в основном в библиотеках: stl, boost, loki и так далее. Конечно, при высокоуровневом программировании использовать такие фокусы череповато - думаю, все помнят конструкцию для получения размера массива:). Но в библиотеках частичная специализация позволяет относительно просто реализовывать делегаты, события, сложные контейнеры и прочие иногда очень нужные и полезные вещи.

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

Update: Обещанное продолжение