[2]), последний вызов в этом примере нельзя разрешить как max(a,int(c)). Это может сделать сам пользователь, явно описав функцию max(int,int). Тогда вступает в силу правило [3]:

template<class T>

T max(T a, T b) { return a>b?a:b; } int max(int,int);

void f(int a, int b, char c, char d)

int m1 = max(a,b); max(int,int)

char m2 = max(c,d); max(char,char) int m3 = max(a,c); max(int,int)

Программисту не нужно давать определение функции max(int,int), оно по умолчанию будет создано по шаблону.

Можно определить шаблон max так, чтобы сработал первоначальный вариант нашего примера:

template<class T1, class T2> T1 max(T1 a, T2 b) { return a>b?a:b; };

void f(int a, int b, char c, char d)

int m1 = max(a,b); int max(int,int)

char m2 = max(c,d); char max(char,char)

int m3 = max(a,c); max(int,char)

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

max(c,i); char max(char,int)

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

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

Параметр шаблона типа не обязательно должен быть именем типа (см. $$R.1 4.2). Помимо имен типов можно задавать строки, имена функций и выражения-константы. Иногда бывает нужно задать как параметр целое:

template<class T, int sz> class buffer {

T v[sz]; буфер объектов произвольного типа ...

void f()

buffer<char,128> buf1; buffer<complex,20> buf2; ...

Мы сделали sz параметром шаблона buffer, а не его объектов, и это означает, что размер буфера должен быть известен на стадии трансляции, чтобы его объекты было можно размещать, не используя свободную память. Благодаря этому свойству такие шаблоны как buffer полезны для реализации

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

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

template<class T> void f1(T);

template<class T> void f2(T*);

template<class T> T f3(int);

template<int i> void f4(int[][i]);

template<int i> void f5(int = i);

template<class T, class C> void f6(T);

template<class T> void f7(const T&, complex);

template<class T> void f8(Vector< List<T> >);

нормально

нормально

ошибка

ошибка

ошибка

ошибка

нормально

нормально

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

Подобного ограничения нет в шаблонах типа для классов. Дело в том, что параметр для такого шаблона нужно указывать всякий раз, когда описывается объект шаблонного класса. С другой стороны, для шаблонных классов возникает вопрос: когда два созданных по шаблону типа можно считать одинаковыми? Два имени шаблонного класса обозначают один и тот же класс, если совпадают имена их шаблонов, а используемые в этих именах параметры имеют одинаковые значения (с учетом возможных определений typedef, вычисления выражений-констант и т.д.). Вернемся к шаблону buffer:

template<class T, int sz> class buffer {

T v[sz];

void f()

buffer<char,20> buf1; buffer<complex,20> buf2; buffer<char,20> buf3; buffer<char,100> buf4;

buf1 buf1 buf1

= buf2; = buf3; = buf4;

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

ошибка: несоответствие типов

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

template<int i> class X { /*

*/ };

void f(int a, int b)

X < a > b>;

Как это понимать: X<a> b и потом

недопустимая лексема, или X< (a>b) >; ?

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

Бьерн Страуструп.

выражением больше чем , используйте скобки: X< (a>b)>.

8.7 Шаблоны типа и производные классы

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

Два созданных по одному шаблону типа будут различны и между ними невозможно отношение наследования кроме единственного случая, когда у этих типов идентичны параметры шаблона. Например:

template<class T>

class Vector { /*

Vector<int> v1; Vector<short> v2; Vector<int> v3;

Здесь v1 и v3 одного типа, а v2 имеет совершенно другой тип. Из того факта, что short преобразуется в int, не следует, что есть неявное преобразование Vector<short> в Vector<int>:

*/ }

неявно

v2 = v3;

несоответствие типов

Но этого и следовало ожидать, поскольку нет встроенного преобразования int[] в short[].

Аналогичный пример:

class circle: public shape { /* ... */ }; Vector<circle*> v4; Vector<shape*> v5; Vector<circle*> v6;

Здесь v4 и v6 одного типа, а v5 имеет совершенно другой тип. Из того факта, что существует неявное преобразование circle в shape и circle* в shape*, не следует, что есть неявные преобразования Vector<circle*> в Vector<shape*> или Vector<circle*>* в Vector<shape*>* :

v5 = v6;

несоответствие типов

Дело в том, что в общем случае структура (представление) класса, созданного по шаблону типа, такова, что для нее не предполагаются отношения наследования. Так, созданный по шаблону класс может содержать объект типа, заданного в шаблоне как параметр, а не просто указатель на него. Кроме того, допущение подобных преобразований приводит к нарушению контроля типов:

void f(Vector<circle>* pc)

Vector<shape>* ps = pc; (*ps)[2] = new square;

ошибка: несоответствие типов

круглую ножку суем в квадратное

отверстие ( память выделена для

square, а используется для circle

На примерах шаблонов Islist, Tlink, Slist, Splist, Islist iter, Slist iter и SortableVector мы видели, что шаблоны типа дают удобное средство для создания целых семейств классов. Без шаблонов создание таких семейств только с помощью производных классов может быть утомительным занятием, а значит, ведущим к ошибкам. С другой стороны, если отказаться от производных классов и использовать только шаблоны, то появляется множество копий функций-членов шаблонных классов, множество копий описательной части шаблонных классов и во множестве повторяются функции, использующие шаблоны типа.