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

В следующей паре вызовов как аргументы передаются массивы, отличающиеся размером, а следовательно, имеющие разные типы. В вызове функции 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 <typename A, typename B>

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 <typename Т> 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.2.1

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

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

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

template <class Т> int compare(const T&, const T&);

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

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

template <typename Т> Т calc(T, int);

template <typename Т> Т fcn(Т, Т);

double d; float f; char с;

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

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

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

template <typename Т> f1(Т, Т);

template <typename T1, typename T2) f2(T1, T2);

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);

16.2.2. Явные аргументы шаблона функции

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

Определение явного аргумента шаблона

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

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

// тип T1 не может быть выведен: он отсутствует в списке параметров

// функции

template <typename T1, typename T2, typename T3>

T1 sum(T2, T3);

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

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

// T1 определяется явно; T2 и T3 выводятся из типов аргумента

auto val3 = sum<long long>(i, lng); // long long sum(int, long)

Этот вызов явно определяет тип параметра T1. Компилятор выведет типы для параметров T2 и T3 из типов переменных i и lng.

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

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

// параметра шаблона

template <typename T1, typename T2, typename T3>

T3 alternative_sum(T2, T1);

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

// ошибка: нельзя вывести начальные параметры шаблона

auto val3 = alternative_sum<long long>(i, lng);

// ok: все три параметра определяются явно

auto val2 = alternative_sum<long long, int, long>(i, lng);

Нормальные преобразования применимы к аргументам, определенным явно

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

long lng;

compare(lng, 1024);       // ошибка: параметры шаблона не совпадают

compare<long>(lng, 1024); // ok: создает экземпляр compare(long, long)

compare<int>(lng, 1024);  // ok: создает экземпляр compare(int, int)

Как уже упоминалось, первый вызов ошибочен, поскольку у аргументов функции compare() должен быть одинаковый тип. Если тип параметра шаблона определен явно, обычные преобразования вполне применимы. Таким образом, вызов compare<long>() эквивалентен вызову функции, получающей два параметра const long&. Параметр типа int автоматически преобразуется в тип long. Во втором вызове параметр Т явно определяется как тип int, таким образом, тип аргумента lng преобразовывается в int.