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

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

Параметризованные типы

Параметризованный тип внешне представляет собой обычное объявление класса, которому предшествует магическое заклинание template <c1ass Type>, где Type - выбранное вами символическое имя (остальные элементы задаются жестко). Всюду, где символическое имя Type (или другое имя) встречается в объявлении класса оно интерпретируется как макрос, вместо которого при использовании класса подставляется конкретный тип. Класс ListNode, переписанный как параметризованный тип, выглядит следующим образом:

template <c1ass Type> class ListNode { private:

ListNode<Type>* next;

Type* data; public:

ListNode(Type* d, ListNode<Type>* n = NULL) : next(n), data(d) {} ~ListNode() { delete next; } Type* Data() { return data; } ListNode<Type>* Next() { return next; }

ListNode<Foo> list = new ListNode<Foo> (new Foo);

Foo* f = 1ist->Data(); Возвращает правильный тип

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

Параметризованные функции

Параметризованные функции объявляются точно так же - перед их объявлениями указывается формула template. ... Синтаксис шаблона должен повторяться как при объявлении, так и при определении функции. Помните, шаблоны на самом деле являются макросами, поэтому они должны находиться в файлах .h. Если определение будет находиться в файле .срр, программа работать не будет (если только это не единственный файл .срр, в котором вызывается данная функция).

Объявление функции template <c1ass Type> Type* fn(Type* t); Определение ее реализации template <c1ass Type> Type* fn(Type* t) {

Тело функции, в котором имя Type

используется в качестве параметра макроса

Foo* f = fn<Foo>(new Foo);

Определение генерируется компилятором при необходимости, то есть при вызове функции. На этот раз параметризовано имя функции, а не имя класса.

Параметризованные функции классов

Параметризованные функции классов определяются так же (разве что вам понадобится больше угловых скобок < и >). Давайте модифицируем класс ListNode так, чтобы его функции не определялись при объявлении класса.

template <c1ass Type> class ListNode { private:

ListNode<Type*> next;

Type* data; public:

ListNode(Type* d, ListNode<Type>* n = NULL); ~ListNode(); Type* Data(); ListNode<Type>* Next();

template <c1ass Type>

ListNode<Type>::ListNode(Type* d, ListNode<Type>* n = NULL) : next(n), data(d)

template <c1ass Type> ListNode<Type>::~ListNode()

delete next;

template <c1ass Type>

Type* ListNode<Type>::Data()

return data;

template <c1ass Type>

ListNode<Type>* ListNode<Type>::Next()

return next;

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

Передача параметра

Многочисленные символы < и > вызывают изрядную путаницу, поскольку C++ не всегда последователен. Вообще говоря, <Туре> следует указывать везде, кроме трех мест в объявлениях классов или определениях их функций:

1. За ключевым словом class в самом начале.

2. При указании имени конструктора.

3. При указании имени деструктора.

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

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

Шаблоны с несколькими параметрами

Тип может иметь более одного параметра, хотя такие ситуации встречаются довольно редко. Увидев такой класс, я обычно затеваю с автором долгую беседу о принципах построения программ. Тем не менее, иногда использование многоаргументных шаблонов бывает оправданным. Синтаксис выглядит аналогично, разве что вместо <c1ass Type> используется список типа <c1ass Type1, class Type2>. Наконец, параметр не обязан быть классом. Он может быть структурой или еще чем-нибудь, хотя именно классы прочно удерживают ведущие позиции на рынке параметров.

Долой вложенные параметризованные типы!

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

template <c1ass Type> class B {...}; template <c1ass Type> class A {

B<A<Type * member; Жуть!

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

Наследование

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

Комбинации простых и параметризованных типов

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

Допустим, вы продаете библиотеку классов и не хотите поставлять исходный текст, а только интерфейсы. Если библиотека содержит параметризованные функции, они должны находиться в открытом для всего мира файле .h. Обидно.

Допустим, кто-то передает вам замечательный, но небезопасный по отношению к типам класс или библиотеку классов. Может быть, он был написан на компиляторе, который не поддерживает шаблоны, или автор просто не верит в шаблоны. Вам хочется подправить код и сделать его безопасным с помощью шаблонов. Но хотите ли вы переделывать все подряд, включать весь код реализации в файлы .h и добавлять в объявления класса параметры и символы <>?