Стенли Липпман - Язык программирования C++. Пятое издание

Другие преобразования, такие как арифметические преобразования (см. раздел 4.11.1), преобразования производного в базовый (см. раздел 15.2.2) и пользовательские преобразования (см. разделы 7.5.4 и 14.9) не выполняются.

В качестве примера рассмотрим вызовы функции fobj()и fref(). Функция fobj()копирует свои параметры, тогда как параметры функции fref()являются ссылками:

template Т fobj(Т, Т); // аргументы копируются

template Т fref(const Т&, const Т&); // ссылки

string s1("a value");

const string s2("another value");

fobj(s1, s2); // вызов fobj(string, string); const игнорируется

fref(s1, s2); // вызов fref(const strings, const string&) использует

// допустимое преобразования в константу для s1

int а[10], b[42];

fobj(a, b); // вызов f(int*, int*)

fref(a, b); // ошибка: типы массивов не совпадают

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

В следующей паре вызовов как аргументы передаются массивы, отличающиеся размером, а следовательно, имеющие разные типы. В вызове функции fobj()различие типов массивов не имеет значения. Оба массива преобразуются в указатели. Типом параметра шаблона в функции fobjявляется int*. Вызов функции fref(), однако, недопустим. Когда параметр является ссылкой, массивы не преобразовываются в указатели (см. раздел 6.2.4). Типы аи bне совпадают, поэтому вызов ошибочен.

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

Параметр типа шаблона применим как тип нескольких параметров функции. Поскольку набор преобразований ограничен, аргументы таких параметров должны быть, по существу, того же типа. Если выведенные типы не совпадают, то вызов ошибочен. Например, функция compare()(см. раздел 16.1.1) получает два параметра const Т&. У ее аргументов должен быть фактически тот же тип:

long lng;

compare(lng, 1024); // ошибка: нельзя создать

// экземпляр compare(long, int)

Этот вызов ошибочен потому, что у аргументов функции compare()не совпадают типы. Для первого аргумента выведен аргумент шаблона типа long; а для второго — int. Эти типы не совпадают, поэтому дедукция аргумента шаблона терпит неудачу.

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

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

template

int flexibleCompare(const A& v1, const B& v2) {

if (v1 < v2) return -1;

if (v2 < v1) return 1;

return 0;

}

Теперь пользователь может предоставлять аргументы разных типов:

long lng;

flexibleCompare(lng, 1024); // ok: вызов flexibleCompare(long, int)

Конечно, должен существовать оператор <, способный сравнивать значения этих типов.

У шаблона функции могут быть параметры, определенные с использованием обычных типов, т.е. типов, которые не задействуют параметр типа шаблона. Такие аргументы не обрабатываются специальным образом; они преобразуются, как обычно, в соответствующий тип параметра (см. раздел 6.1). Рассмотрим, например, следующий шаблон:

template ostream &print(ostream &os, const T &obj) {

return os << obj;

}

Тип первого параметра функции известен: ostream&. У второго параметра, obj, тип параметра шаблона. Поскольку тип параметра osфиксирован, при вызове функции print()к переданным ему аргументам применимы обычные преобразования:

print(cout, 42); // создает экземпляр print(ostream&, int)

ofstream f("output");

print(f, 10); // использует print(ostream&, int);

// преобразует f в ostream&

В первом вызове тип первого аргумента точно соответствует типу первого параметра. Этот вызов задействует ту версию функции print(), которая получает тип ostream&и тип intдля создания экземпляра. Во втором вызове первый аргумент имеет тип ofstream, а преобразование из ofstreamв ostream&допустимо (см. раздел 8.2.1). Поскольку тип этого параметра не зависит от параметра шаблона, компилятор неявно преобразует fв ostream&.

Обычные преобразования применимы к аргументам, тип которых не является параметром шаблона.

Упражнение 16.32. Что происходит при дедукции аргумента шаблона?

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

Упражнение 16.34. С учетом только следующего кода объясните, допустим ли каждый из этих вызовов. Если да, то каков тип Т? Если нет, то почему?

template int compare(const T&, const T&);

(a) compare("hi", "world"); (b) compare("bye", "dad");

Упражнение 16.35. Какой из следующих вызовов ошибочен (если он есть)? Каков тип Тдопустимых вызовов? В чем проблема недопустимых вызовов?

template Т calc(T, int);

template Т fcn(Т, Т);

double d; float f; char с;

(a) calc(с, 'c'); (b) calc(d, f);

(c) fcn(c, 'c'); (d) fcn(d, f);

Упражнение 16.36. Что происходит при следующих вызовах:

template f1(Т, Т);

template

int i = 0, j = 42, *p1 = &i, *p2 = &j;

const int *cp1 = &i, *cp2 = &j;

(a) f1(p1, p2); (b) f2(p1, p2); (c) f1(cp1, cp2);

(d) f2(cp1, cp2); (e) f1(p1, cp1); (e) f2(p1, cp1);

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

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