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

• debug_rep(const string*&) — экземпляр первой версии функции debug_rep()с привязкой параметра Тк типу string*;

• debug_rep(string*)— экземпляр второй версии функции debug_rep()с привязкой параметра Тк типу string.

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

В качестве другого примера рассмотрим следующий вызов:

const string *sp = &s;

cout << debug_rep(sp) << endl;

Здесь подходящими являются оба шаблона, и оба обеспечивают точное соответствие:

• debug_rep(const string*&)— экземпляр первой версии шаблона с привязкой параметра Тк типу const string*;

• debug_rep(const string*)— экземпляр второй версии шаблона с привязкой параметра Тк типу const string.

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

Причина для этого правила в том, что без него не было бы никакого способа вызвать версию функции debug_rep()для указателя на константу. Проблема в том, что к шаблону debug_rep(const Т&)подходит практически любой тип, включая типы указателя. Этот шаблон является более общим, чем debug_rep(Т*), который может быть вызван только для типов указателя. Без этого правила вызовы с передачей указателей на константу всегда будут неоднозначны.

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

Для следующего примера определим обычную, не шаблонную версию функции debug_rep(), выводящую строки в двойных кавычках:

// вывод строк в двойных кавычках

string debug_rep(const string &s) {

return '"' + s + '"';

}

Теперь, когда происходит вызов функции debug_rep()для строки:

string s("hi");

cout << debug_rep(s) << endl;

есть две одинаково хорошо подходящих функции:

• debug_rep(const string&)— первый шаблон с привязкой параметра Tк типу string;

• debug_rep(const string&)— обычная, не шаблонная функция.

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

Когда нешаблонная функция обеспечивает одинаково хорошее соответствие с шаблонной функцией, предпочитается нешаблонная версия.

До сих пор не рассматривался случай с указателями на символьные строки в стиле С и строковые литералы. Теперь, когда имеется версия функции debug_rep(), получающая строку, можно было бы ожидать, что ей будет соответствовать вызов, которому переданы символьные строки. Однако рассмотрим этот вызов:

cout << debug_rep("hi world!") << endl; // вызов debug_rep(T*)

Здесь подходящими являются все три функции debug_rep():

• debug_rep(const Т&)— с привязкой параметра Тк типу char[10];

• debug_rep(Т*)— с привязкой параметра Тк типу соnst char;

• debug_rep(const string&)— требующая преобразования из const char*в string.

Оба шаблона обеспечивают точное соответствие аргументу — второй шаблон требует (допустимого) преобразования из массива в указатель, и это преобразование считается точным соответствием при подборе функции (см. раздел 6.6.1). Нешаблонная версия является подходящей, но требует пользовательского преобразования. Эта функция хуже точного соответствия, поэтому кандидатами остаются два шаблона. Как и прежде, версия Т*более специализирована, она и будет выбрана.

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

// преобразовать символьные указатели в строку и вызвать строковую

// версию debug_rep()

string debug_rep(char *p) {

return debug_rep(string(p));

}

string debug_rep(const char *p) {

return debug_rep(string(p));

}

Следует заметить, что для правильной работы версии char*функции debug_rep()объявление debug_rep(const string&)должно находиться в области видимости, когда эти функции определяются. В противном случае будет вызвана неправильная версия функции debug_rep():

template string debug_rep(const T &t);

template string debug_rep(T *p);

// следующее объявление должно быть в области видимости

// для правильного определения debug_rep(char *)

string debug_rep(const string &);

string debug_rep(char *p) {

// если объявление для версии, получающей const string&, не находится

// в области видимости, return вызовет call debug_rep(const Т&) с

// экземпляром строки в параметре Т

return debug_rep(string(p));

}

Обычно, если попытаться использовать функцию, которую забыли объявлять, код не будет откомпилирован. Но с функциями, которые перегружают шаблон функции, все не так. Если компилятор может создать экземпляр вызова из шаблона, то отсутствие объявления не будет иметь значения. В этом примере, если забыть объявлять версию функции debug_rep(), получающую строку, компилятор тихо создаст версию экземпляра шаблона, получающую const Т&.

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

Упражнение 16.48. Напишите собственные версии функций debug_rep().

Упражнение 16.49. Объясните, что происходит в каждом из следующих вызовов:

template void f(Т);