Язык программирования C++. Вводный курс. С для начинающих
 Скачать 5.41 Mb.
|
|
503 } Для вызова min(ai[0],ss) из call_instantiation нет ни одной функции-кандидата. Попытка сгенерировать ее из шаблона min() провалится, поскольку для аргумента шаблона Type из фактических аргументов функции выводятся два разных значения. Следовательно, такой вызов ошибочен. Однако при обращении к min(ai[0],ss) внутри main() видимо объявление обычной функции min(int, int). Тип первого фактического аргумента этой функции точно соответствует типу формального параметра, а второй аргумент может быть преобразован в тип формального параметра с помощью расширения типа. Поскольку для второго вызова устояла только данная функция, то она и вызывается. Разобравшись с разрешением перегрузки функций, конкретизированных из шаблонов, специализацией шаблонов функций и обычных функций с тем же именем, подытожим все, что мы об этом рассказали: 1. Построить множество функций-кандидатов. Рассматриваются шаблоны функций с тем же именем, что и вызванная. Если аргументы шаблона выведены из фактических аргументов функции успешно, то в множество функций-кандидатов включается либо конкретизированный шаблон, либо специализация шаблона для выведенных аргументов, если она существует. 2. Построить множество устоявших функций (см. раздел 9.3). В множестве функций-кандидатов остаются только функции, которые можно вызвать с данными фактическими аргументами. 3. Ранжировать преобразования типов (см. раздел 9.3). a. Если есть только одна функция, вызвать именно ее. b. Если вызов неоднозначен, удалить из множества устоявших функции, конкретизированные из шаблонов. 4. Разрешить перегрузку, рассматривая среди всех устоявших только обычные функции (см. раздел 9.3). a. Если есть только одна функция, вызвать именно ее. // определение шаблона функции template Type min( Type t1, Type t2 ) { ... } int ai[4] = { 22, 33, 44, 55 }; short ss = 88; void call_instantiation() { // ошибка: для этого вызова нет функции-кандидата min( ai[0], ss ); } // обычная функция int min( int a1, int a2 ) { min } int main() { call_instantiation() { // вызывается обычная функция min( ai[0], ss ); С++ для начинающих 504 b. В противном случае вызов неоднозначен. Проиллюстрируем эти шаги на примере. Предположим, есть два объявления – шаблона функции и обычной функции. Оба принимают аргументы типа double: double max( double, double ); А вот три вызова max(). Можете ли вы сказать, какая функция будет вызвана в каждом случае? } Рассмотрим последовательно все три вызова: 1. max(0,ival). Оба аргумента имеют тип int. Для вызова есть два кандидата: конкретизированная из шаблона функция max(int, int) и обычная функция max(double, double) Конкретизированная функция точно соответствует фактическим аргументам, поэтому она и вызывается; 2. max(0.25,double). Оба аргумента имеют тип double. Для вызова есть два кандидата: конкретизированная из шаблона max(double, double) и обычная max(double, double) . Вызов неоднозначен, поскольку точно соответствует обеим функциям. Правило 3b говорит, что в таком случае выбирается обычная функция;. 3. max(0,fd). Аргументы имеют тип int и float соответственно. Для вызова существует только один кандидат: обычная функция max(double, double). Вывод аргументов шаблона заканчивается неудачей, так как значения типа Type, выведенные из разных фактических аргументов функции, различны. Поэтому в множество кандидатов конкретизированная из шаблона функция не попадает. Обычная же функция устояла, поскольку существуют преобразования типов фактических аргументов в типы формальных параметров; она и выбирается. Если бы обычная функция не была объявлена, вызов закончился бы ошибкой. А если бы мы определили еще одну обычную функцию для max()? Например: template Type max( Type, Type ) { ... } // обычная функция int main() { int ival; double dval; float fd; // ival, dval и fd присваиваются значения max( 0, ival ); max( 0.25, dval ); max( 0, fd ); С++ для начинающих 505 double max( double, double ); Будет ли в таком случае третий вызов разрешен по-другому? Да. } Правило 3b говорит, что, поскольку вызов неоднозначен, следует рассматривать только обычные функции. Ни одна из них не считается наилучшей из устоявших, так как преобразования типов фактических аргументов одинаково плохи: в обоих случаях для установления соответствия требуется стандартная трансформация. Таким образом, вызов неоднозначен, и компилятор сообщает об ошибке. Упражнение 10.11 Вернемся к представленному ранее примеру: double max( double, double ); } Добавим в множество объявлений в глобальной области видимости следующую специализацию шаблона функции: template <> char max Составьте список кандидатов и устоявших функций для каждого вызова max() внутри main() Предположим, что в main() добавлен следующий вызов: template // две обычные функции char max( char, char ); int main() { float fd; // в пользу какой функции разрешается вызов? max( 0, fd ); template Type max( Type, Type ) { ... } int main() { int ival; double dval; float fd; max( 0, ival ); max( 0.25, dval ); max( 0, fd ); С++ для начинающих 506 } В пользу какой функции он будет разрешен? Почему? Упражнение 10.12 Предположим, что есть следующее множество определений и специализаций шаблонов, а также объявления переменных и функций: double calc( double, double ); Выясните, какая функция или конкретизированный шаблон вызывается в каждом из показанных ниже случаев. Для каждого вызова перечислите функции-кандидаты и устоявшие функции; объясните, какая из устоявших функций будет наилучшей. (c) calc( ia[0], 1 ); (f) calc( &i, i ); 10.9. Разрешение имен в определениях шаблонов А Внутри определения шаблона смысл некоторых конструкций может различаться в зависимости от конкретизации, тогда как смысл других всегда остается неизменным. Главную роль играет наличие в конструкции формального параметра шаблона: } В функции min() типы переменных array и min_val зависят от фактического типа, которым будет заменен Type при конкретизации шаблона, тогда как тип переменной int main() { // ... max( 0, 'j' ); int i; unsigned int ui; char str[24]; int ia[24]; template (a) cslc( str, 24 ); (d) calc( i, ui ); (b) calc( is, 24 ); (e) calc( ia, ui ); template Type min( Type* array, int size ) { Type min_val = array[0]; for (int i = 1; i < size; ++i) if ( array[i] < min_val ) min_val = array[i]; print( "Minimum value found: "); print( min_val ); return min_val; С++ для начинающих 507 size останется int при любом типе параметра шаблона. Следовательно, типы array и min_val в разных конкретизациях различны. Поэтому мы говорим, что типы этих переменных зависят от параметра шаблона, тогда как тип size от него не зависит. Так как тип min_val неизвестен, то неизвестна и операция, которая будет использоваться при появлении min_val в выражении. Например, какая функция print() будет вызвана при обращении print(min_val)? С типом аргумента int? Или float? Будет ли вызов ошибочным, поскольку не существует функции, которая может быть вызвана с аргументом того же типа, что и min_val? Принимая все это во внимание, мы говорим, что и вызов print(min_val) зависит от параметра шаблона. Такие вопросы не возникают для тех конструкций внутри min(), которые не зависят от параметров шаблона. Например, всегда известно, какая функция должна быть вызвана для print( "Minimum value found: "). Это функция печати строк символов. В данном случае print() остается одной и той же при любой конкретизации шаблона, то есть не зависит от его параметров. В главе 7 мы видели, что в C++ функция должна быть объявлена до ее вызова. Нужно ли объявлять функцию, вызываемую внутри шаблона, до того, как компилятор увидит его определение? Должны ли мы объявить функцию print() в предыдущем примере до определения шаблона min()? Ответ зависит от особенностей имени, на которое мы ссылаемся. Конструкцию, не зависящую от параметров шаблона, следует объявить перед ее использованием в шаблоне. Представленное выше определение шаблона функции min() некорректно. Поскольку вызов print( "Minimum value found: "); не зависит от параметров шаблона, то функция print() для печати строк символов должна быть объявлена до использования. Чтобы исправить эту ошибку, можно поместить объявление print() перед определением min(): } С другой стороны, объявление функции print(), используемой для печати min_val, пока не нужно, так как еще неизвестно, какую конкретно функцию надо искать. Мы не знаем, какая функция print() будет вызвана при обращении print(min_val), пока тип min_val не станет известным. // ---- primer.h ---- // это объявление необходимо: // внутри min() вызывается print( const char * ) void print( const char * ); template Type min( Type* array, int size ) { // ... print( "Minimum value found: "); print( min_val ); return min_val; С++ для начинающих 508 Когда же должна быть объявлена функция print(), вызываемая при обращении print(min_val) ? До конкретизации шаблона. Например: } main() вызывает конкретизированную из шаблона функцию min(int*,int). В этой реализации Type заменено int, и тип переменной min_val, следовательно, равен int. Поэтому при обращении print(min_val) вызывается функция с аргументом типа int. Именно тогда, когда конкретизируется min(int*,int), становится известно, что при втором вызове аргумент print() имеет тип int. В этот момент такая функция должна быть видима. Если бы функция print(int) не была объявлена до конкретизации min(int*,int) , то компилятор выдал бы сообщение об ошибке. Поэтому разрешение имен в определении шаблона происходит в два этапа. Сначала разрешаются имена, не зависящие от его параметров, а затем, при конкретизации, – имена, зависящие от параметров. Но зачем нужны два шага? Почему бы, например, не разрешать все имена при конкретизации? Если вы проектируете шаблон функции, то, вероятно, хотели бы сохранить контроль над тем, когда разрешаются имена в его определении. Предположим, что шаблон min() – это часть библиотеки, в которой определены и другие шаблоны и функции. Желательно, чтобы реализации min() по возможности использовали другие компоненты нашей же библиотеки. В предыдущем примере интерфейс библиотеки определен в заголовочном файле . Как объявление функции print(const char*), так и определение функции min() являются частями интерфейса. Мы хотим, чтобы конкретизации шаблона min() пользовались функцией print() из нашей библиотеки. Первый этап разрешения имени это гарантирует. Если имя, использованное в определении шаблона, не зависит от его параметров, то оно обязательно будет относиться к компоненту внутри библиотеки, т.е. к тому объявлению, которое включено в один пакет с этим определением в заголовочном файле На самом деле автор шаблона должен позаботиться о том, чтобы были объявлены все имена, использованные в определениях и не зависящие от параметров. Если этого нет, то определение шаблона вызовет ошибку. При конкретизации шаблона компилятор ее не исправляет: #include void print( int ); int ai[4] = {12, 8, 73, 45 }; int main() { int size = sizeof(ai) / sizeof(int); // конкретизируется min( int*, int ) min( &ai[0], size ); С++ для начинающих 509 } Объявление функции print( const char* ) в файле user.C невидимо в том месте, где появляется определение шаблона. Однако оно видимо там, где конкретизируется шаблон min(int*,int) , но это объявление не рассматривается при компиляции вызова print("Minimum value found: ") , так как последний не зависит от параметров шаблона. Если некоторая конструкция в определении шаблона не зависит от его параметров, то имена разрешаются в контексте самого определения, и результат разрешения в дальнейшем не пересматривается. Поэтому на программиста возлагается ответственность за то, чтобы объявления имен, встречающихся в определении, были включены в интерфейс библиотеки вместе с шаблоном. А теперь предположим, что библиотека была написана кем-то другим, а мы ее пользователи, которым доступен интерфейс, определенный в заголовочном файле . Иногда нужно, чтобы объекты и функции, определенные в нашей программе, учитывались при конкретизации шаблона из библиотеки. Допустим, мы определили в своей программе класс SmallInt и хотели бы конкретизировать функцию min() из библиотеки для получения минимального значения в массиве объектов типа SmallInt. При конкретизации шаблона min() для массива объектов типа SmallInt вместо аргумента шаблона Type подставляется тип SmallInt. Следовательно, min_val в конкретизированной функции min() имеет тот же тип. Тогда как разрешится вызов функции print(min_val)? // ---- primer.h ---- template Type min( Type* array, int size ) { Type min_val = array[0]; // ... // ошибка: функция print( const char* ) не найдена print( "Minimum value found: " ); // правильно: зависит от параметра шаблона print( min_val ); // ... } // ---- user.C ---- #include // это объявление print( const char* ) игнорируется void print( const char* ); void print( int ); int ai[4] = {12, 8, 73, 45 }; int main() { int size = sizeof(ai) / sizeof(int); // конкретизируется min( int*, int ) min( &ai[0], size ); С++ для начинающих 510 } Это нормально: мы хотим, чтобы учитывалась именно наша функция print(const SmallInt &) . Рассмотрения функций, определенных в библиотеке , недостаточно. Второй шаг разрешения имени гарантирует, что если имя, использованное в определении, зависит от параметров шаблона, то принимаются во внимание имена, объявленные в контексте конкретизации. Поэтому можно быть уверенным, что функции, умеющие манипулировать объектами типа SmallInt, попадут в поле зрения компилятора при анализе шаблона, которому в качестве аргумента передан тип SmallInt. Место в программе, где происходит конкретизация шаблона, называется точкой конкретизации. Знание этой точки важно потому, что она определяет, какие объявления учитывает компилятор для имен, зависящих от параметров шаблона. Такая точка всегда находится в области видимости пространства имен и следует за функцией, внутри которой произошла конкретизация. Например, точка конкретизации min(SmallInt*,int) расположена сразу после функции main() в области видимости пространства имен: { /* ... */ } Но что, если конкретизация шаблона случается в одном исходном файле несколько раз? Где тогда будет точка конкретизации? Вы можете спросить: “А какая, собственно, разница?” В нашем примере для SmallInt разница есть, поскольку объявление функции print(const SmallInt &) должно появиться перед точкой конкретизации min(SmallInt*,int) : // ---- user.h ---- class SmallInt { /* ... */ } void print( const SmallInt & ); // ---- user.C ---- #include #include "user.h" SmallInt asi[4]; int main() { // задать значения элементов массива asi // конкретизируется min( SmallInt*, int ) // int size = sizeof(asi) / sizeof(SmallInt); min( &asi[0], size ); // ... int main() { // ... // использование min(SmallInt*,int) min( &asi[0], size ); } // точка конкретизации min(SmallInt*,int) // как будто объявление конкретизированной функции выглядит так: SmallInt min( SmallInt* array, int size ) С++ для начинающих 511 // или здесь? В действительности точка конкретизации находится после определения каждой функции, в которой используется конкретизированный экземпляр. Компилятор может выбрать любую из этих точек, чтобы конкретизировать в ней шаблон. Отсюда следует, что при организации кода программы надо быть внимательным и помещать все объявления, необходимые для разрешения имен, зависящих от параметров некоторого шаблона, перед первой точкой. Поэтому разумно поместить их в заголовочный файл, который включается перед любой возможной конкретизацией шаблона: // вторая точка конкретизации min(SmallInt*,int) А если конкретизация шаблона происходит в нескольких файлах? Например, что будет, если функция another() находится в другом файле, нежели main()? Тогда точка конкретизации есть в каждом файле, где используется конкретизированная из шаблона функция. Компилятор свободен в выборе любой из них, так что нам снова придется проявить аккуратность и включить файл "user.h" во все исходные файлы, где используются конкретизированные функции. Тем самым гарантируется, что реализация min(SmallInt*,int) будет ссылаться именно на нашу функцию print(const SmallInt &) вне зависимости от того, какую из точек конкретизации выберет компилятор. #include void another(); SmallInt asi[4]; int main() { // задать значения элементов массива asi int size = sizeof(asi) / sizeof(SmallInt); min( &asi[0], size ); another(); // ... } // точка конкретизации здесь? void another() { int size = sizeof(asi) / sizeof(SmallInt); min( &asi[0], size ); } #include // user.h содержит объявления, необходимые при конкретизации #include "user.h" void another(); SmallInt asi[4]; int main() { // ... } // первая точка конкретизации min(SmallInt*,int) void another() { // ... } С++ для начинающих 512 Упражнение 10.13 Назовите два шага разрешения имени в определениях шаблона. Объясните, каким образом первый шаг отвечает потребностям разработчика библиотеки, а второй обеспечивает гибкость, необходимую пользователям шаблонов. Упражнение 10.14 На какие объявления ссылаются имена display и SIZE в реализации max(LongDouble*,SIZE) ? } 10.10. Пространства имен и шаблоны функций А Как и любое другое глобальное определение, шаблон функции может быть помещен в пространство имен (см. обсуждение пространств имен в разделах 8.5 и 8.6). Мы получили бы ту же семантику, если бы определили шаблон в глобальной области видимости, скрыв его имя внутри пространства имен. При использовании вне этого пространства необходимо либо квалифицировать имя шаблона именем пространства имен, либо использовать using-объявление: // ---- exercise.h ---- void display( const void* ); typedef unsigned int SIZE; template Type max( Type* array, SIZE size ) { Type max_val = array[0]; for ( SIZE i = 1; i < size; ++i ) if ( array[i] > max_val ) max_val = array[i]; display( "Maximum value found: " ); display( max_val ); return max_val; } // ---- user.h ---- class LongDouble { /* ... */ }; void display( const LongDouble & ); void display( const char * ); typedef int SIZE; // ---- user.C ---- #include #include "user.h" LongDouble ad[7]; int main() { // задать значения элементов массива ad // конкретизируется max( LongDouble*, SIZE ) SIZE size = sizeof(ad) / sizeof(LongDouble); max( &ad[0], size ); |