Разрешение перегрузки для шаблонной функции

8.5 Разрешение перегрузки для шаблонной функции

К параметрам шаблонной функции нельзя применять никаких преобразований

типа. Вместо этого при необходимости создаются новые варианты

функции:
template T sqrt(t);

{

complex z1 = sqrt(i); // sqrt(int)

complex z3 = sqrt(z); // sqrt(complex)

// ...

}
Здесь для всех трех типов параметров будет создаваться по шаблону

например вызвать sqrt(double), задавая параметр int, нужно

использовать явное преобразование типа:
template T sqrt(T);
void f(int i, double d, complex z)

{

complex z1 = sqrt(double(i)); // sqrt(double)

complex z3 = sqrt(z); // sqrt(complex)

// ...

}
В этом примере по шаблону будут создаваться определения только для

Шаблонная функция может перегружаться как простой, так и шаблонной

функцией того же имени. Разрешение перегрузки как шаблонных, так и

обычных функций с одинаковыми именами происходит за три шагаЬ:

чтобы разрешить преобразования ссылок и указателей, а, возможно,

и другие стандартные преобразования. Как обычно, при таких

преобразованиях будет действовать контроль однозначности.

если такая есть, вызвать ее.

[2] Найти шаблон типа, по которому можно создать вызываемую

функцию с точным сопоставлением параметров; если такая есть,

вызвать ее.

[3] Попробовать правила разрешения для обычных функций ($$r13.2);

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

вызов является ошибкой.

В любом случае, если на первом шаге найдено более одной функции,

вызов считается неоднозначным и является ошибкой. Например:

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

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,char)

}
Поскольку до генерации функции по шаблону не применяется никаких

преобразований типа (правило [2]), последний вызов в этом

примере нельзя разрешить как max(a,int(c)). Это может сделать сам

пользователь, явно описав функцию max(int,int). Тогда вступает

в силу правило [3]:

template

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

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.14.2). Помимо имен типов можно задавать строки, имена

функций и выражения-константы. Иногда бывает нужно задать

как параметр целое:
template class buffer {

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

// ...

};
void f()

{

buffer buf1;

buffer buf2;

// ...

}
Мы сделали sz параметром шаблона buffer, а не его объектов, и это

означает, что размер буфера должен быть известен на стадии

трансляции, чтобы его объекты было можно размещать, не используя

свободную память. Благодаря этому свойству такие шаблоны как buffer

полезны для реализации контейнерных классов, поскольку для последних

первостепенным фактором, определяющим их эффективность, является

возможность размещать их вне свободной памяти. Например, если в

реализации класса string короткие строки размещаются в стеке, это дает

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

практически все строки очень короткие. Для реализации таких типов как

раз и может пригодиться шаблон buffer.

Каждый параметр шаблона типа для функции должен влиять на тип

функции, и это влияние выражается в том, что он участвует по

крайней мере в одном из типов формальных параметров функций,

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

выбирать и создавать, основываясь только на их параметрах:

template void f1(T); // нормально

template void f2(T*); // нормально

template T f3(int); // ошибка

template void f4(int[][i]); // ошибка

template void f5(int = i); // ошибка

template void f6(T); // ошибка

template void f7(const T&, complex); // нормально

template void f8(Vector< List >); // нормально

Здесь все ошибки вызваны тем, что параметр-тип шаблона никак не

влияет на формальные параметры функций.

Подобного ограничения нет в шаблонах типа для классов. Дело в том,

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

описывается объект шаблонного класса. С другой стороны, для шаблонных

классов возникает вопрос: когда два созданных по шаблону типа можно

считать одинаковыми? Два имени шаблонного класса обозначают один и

тот же класс, если совпадают имена их шаблонов, а используемые в этих

именах параметры имеют одинаковые значения (с учетом возможных

определений typedef, вычисления выражений-констант и т.д.). Вернемся

к шаблону buffer:
template

class buffer {

T v[sz];

// ...

};
void f()

{

buffer buf1;

buffer buf2;

buffer buf3;

buffer buf4;
buf1 = buf2; // ошибка: несоответствие типов

buf1 = buf3; // нормально

buf1 = buf4; // ошибка: несоответствие типов

// ...

}
Если в шаблоне типа для класса используются параметры, задающие

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

template

class X { /* ... */ };

void f(int a, int b)

{

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

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

}
Этот пример синтаксически ошибочен, поскольку первая угловая скобка

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

понадобится параметр шаблона, являющийся выражением "больше чем",

используйте скобки: X< (a>b)>.

жүктеу/скачать 3.27 Mb.

Достарыңызбен бөлісу: