Язык программирования C++. Вводный курс. С для начинающих
 Скачать 5.41 Mb.
|
|
467 10 10. Шаблоны функций В этой главе рассказывается, что такое шаблон функции, как его определять и использовать. Это довольно просто, и многие программисты применяют шаблоны, определенные в стандартной библиотеке, даже не понимая, с чем они работают. Только пользователи, хорошо знающие язык С++, самостоятельно определяют и применяют шаблоны функций так, как здесь описано. Поэтому материал данной главы следует рассматривать как переход к более сложным аспектам C++. Мы начнем с рассказа о том, что такое шаблон функции и как его определять, затем на простом примере проиллюстрируем использование шаблонов. Далее мы перейдем к темам, требующим больших знаний. Сначала посмотрим на усложненные примеры применения шаблонов, затем подробно остановимся на выведении (deduction) их аргументов и покажем, как их можно задавать при конкретизации (instantiation) шаблона функции. После этого мы посмотрим, каким образом компилятор конкретизирует шаблоны и какие требования предъявляются в этой связи к организации наших программ, а также обсудим, как определить специализацию для такой конкретизации. Затем в данной главе будут изложены вопросы, представляющие интерес для проектировщиков шаблонов функций. Мы объясним, как можно перегружать шаблоны и как применительно к ним работает разрешение перегрузки. Мы также расскажем о разрешении имен в определениях шаблонов функций и покажем, как можно определять шаблоны в пространствах имен. Глава завершается развернутым примером. 10.1. Определение шаблона функции Иногда может показаться, что сильно типизированный язык создает препятствия для реализации совсем простых функций. Например, хотя следующий алгоритм функции min() тривиален, сильная типизация требует, чтобы его разновидности были реализованы для всех типов, которые мы собираемся сравнивать: } Заманчивую альтернативу явному определению каждого экземпляра функции min() представляет использование макросов, расширяемых препроцессором: #define min(a, b) ((a) < (b) ? (a) : (b)) Но этот подход таит в себе потенциальную опасность. Определенный выше макрос правильно работает при простых обращениях к min(), например: int min( int a, int b ) { return a < b ? a : b; } double min( double a, double b ) { return a < b ? a : b; С++ для начинающих 468 min( 10.0, 20.0 ); но может преподнести сюрпризы в более сложных случаях: такой механизм ведет себя не как вызов функции, он лишь выполняет текстовую подстановку аргументов. В результате значения обоих аргументов оцениваются дважды: один раз при сравнении a и b, а второй – при вычислении возвращаемого макросом результата: } На первый взгляд, эта программа подсчитывает количество элементов в массиве ia целых чисел. Но в этом случае макрос min() расширяется неверно, поскольку операция постинкремента применяется к аргументу-указателю дважды при каждой подстановке. В результате программа печатает строку, свидетельствующую о неправильных вычислениях: elem_cnt : 5 expecting: 10 Шаблоны функций предоставляют в наше распоряжение механизм, с помощью которого можно сохранить семантику определений и вызовов функций (инкапсуляция фрагмента кода в одном месте программы и гарантированно однократное вычисление аргументов), не принося в жертву сильную типизацию языка C++, как в случае применения макросов. Шаблон дает алгоритм, используемый для автоматической генерации экземпляров функций с различными типами. Программист параметризует все или только некоторые типы в интерфейсе функции (т.е. типы формальных параметров и возвращаемого значения), оставляя ее тело неизменным. Функция хорошо подходит на роль шаблона, если ее реализация остается инвариантной на некотором множестве экземпляров, различающихся типами данных, как, скажем, в случае min(). Так определяется шаблон функции min(): min( 10, 20 ); #include #define min(a,b) ((a) < (b) ? (a) : (b)) const int size = 10; int ia[size]; int main() { int elem_cnt = 0; int *p = &ia[0]; // подсчитать число элементов массива while ( min(p++,&ia[size]) != &ia[size] ) ++elem_cnt; cout << "elem_cnt : " << elem_cnt << "\texpecting: " << size << endl; return 0; С++ для начинающих 469 } Если вместо макроса препроцессора min() подставить в текст предыдущей программы этот шаблон, то результат будет правильным: elem_cnt : 10 expecting: 10 (В стандартной библиотеке C++ есть шаблоны функций для многих часто используемых алгоритмов, например для min(). Эти алгоритмы описываются в главе 12. А в данной вводной главе мы приводим собственные упрощенные версии некоторых алгоритмов из стандартной библиотеки.) Как объявление, так и определение шаблона функции всегда должны начинаться с ключевого слова template, за которым следует список разделенных запятыми идентификаторов, заключенный в угловые скобки '<' и '>', – список параметров шаблона, обязательно непустой. У шаблона могут быть параметры-типы, представляющие некоторый тип, и параметры-константы, представляющие фиксированное константное выражение. Параметр-тип состоит из ключевого слова class или ключевого слова typename, за которым следует идентификатор. Эти слова всегда обозначают, что последующее имя относится к встроенному или определенному пользователем типу. Имя параметра шаблона выбирает программист. В приведенном примере мы использовали имя Type, но могли выбрать и любое другое: } При конкретизации (порождении конкретного экземпляра) шаблона вместо параметра- типа подставляется фактический встроенный или определенный пользователем тип. Любой из типов int, double, char*, vector Параметр-константа выглядит как обычное объявление. Он говорит о том, что вместо имени параметра должно быть подставлено значение константы из определения шаблона. Например, size – это параметр-константа, который представляет размер массива arr: template Type min2( Type a, Type b ) { return a < b ? a : b; } int main() { // правильно: min( int, int ); min( 10, 20 ); // правильно: min( double, double ); min( 10.0, 20.0 ); return 0; template Glorp min2( Glorp a, Glorp b ) { return a < b ? a : b; С++ для начинающих 470 Type min( Type (&arr) [size] ); Вслед за списком параметров шаблона идет объявление или определение функции. Если не обращать внимания на присутствие параметров в виде спецификаторов типа или констант, то определение шаблона функции выглядит точно так же, как и для обычных функций: } В этом примере Type определяет тип значения, возвращаемого функцией min(), тип параметра r_array и тип локальной переменной min_val; size задает размер массива r_array . В ходе работы программы при использовании функции min() вместо Type могут быть подставлены любые встроенные и определенные пользователем типы, а вместо size – те или иные константные выражения. (Напомним, что работать с функцией можно двояко: вызвать ее или взять ее адрес). Процесс подстановки типов и значений вместо параметров называется конкретизацией шаблона. (Подробнее мы остановимся на этом в следующем разделе.) Список параметров нашей функции min() может показаться чересчур коротким. Как было сказано в разделе 7.3, когда параметром является массив, передается указатель на его первый элемент, первая же размерность фактического аргумента-массива внутри определения функции неизвестна. Чтобы обойти эту трудность, мы объявили первый параметр min() как ссылку на массив, а второй – как его размер. Недостаток подобного подхода в том, что при использовании шаблона с массивами одного и того же типа int, но разных размеров генерируются (или конкретизируются) различные экземпляры функции min(). Имя параметра разрешено употреблять внутри объявления или определения шаблона. Параметр-тип служит спецификатором типа; его можно использовать точно так же, как спецификатор любого встроенного или пользовательского типа, например в объявлении переменных или в операциях приведения типов. Параметр-константа применяется как константное значение – там, где требуются константные выражения, например для задания размера в объявлении массива или в качестве начального значения элемента перечисления. template Type min( const Type (&r_array)[size] ) { /* параметризованная функция для отыскания * минимального значения в массиве */ Type min_val = r_array[0]; for ( int i = 1; i < size; ++i ) if ( r_array[i] < min_val ) min_val = r_array[i]; return min_val; С++ для начинающих 471 } Если в глобальной области видимости объявлен объект, функция или тип с тем же именем, что у параметра шаблона, то глобальное имя оказывается скрытым. В следующем примере тип переменной tmp не double, а тот, что у параметра шаблона Type : } Объект или тип, объявленные внутри определения шаблона функции, не могут иметь то же имя, что и какой-то из параметров: } Имя параметра-типа шаблона можно использовать для задания типа возвращаемого значения: T1 min( T2, T3 ); В одном списке параметров некоторое имя разрешается употреблять только один раз. Например, следующее определение будет помечено как ошибка компиляции: // size определяет размер параметра-массива и инициализирует // переменную типа const int template Type min( const Type (&r_array)[size] ) { const int loc_size = size; Type loc_array[loc_size]; // ... typedef double Type; template Type min( Type a, Type b ) { // tmp имеет тот же тип, что параметр шаблона Type, а не заданный // глобальным typedef Type tm = a < b ? a : b; return tmp; template Type min( Type a, Type b ) { // ошибка: повторное объявление имени Type, совпадающего с именем // параметра шаблона typedef double Type; Type tmp = a < b ? a : b; return tmp; // правильно: T1 представляет тип значения, возвращаемого min(), // а T2 и T3 – параметры-типы этой функции template С++ для начинающих 472 Type min( Type, Type ); Однако одно и то же имя можно многократно применять внутри объявления или определения шаблона: Type min( Type, Type ); Type max( Type, Type ); Имена параметров в объявлении и определении не обязаны совпадать. Так, все три объявления min() относятся к одному и тому же шаблону функции: Type min( Type a, Type b ) { /* ... */ } Количество появлений одного и того же параметра шаблона в списке параметров функции не ограничено. В следующем примере Type используется для представления двух разных параметров: Type sum( const vector Если шаблон функции имеет несколько параметров-типов, то каждому из них должно предшествовать ключевое слово class или typename: T sum( T*, U ); // ошибка: неправильное повторное использование имени параметра Type template // правильно: повторное использование имени Type внутри шаблона template // все три объявления min() относятся к одному и тому же шаблону функции // опережающие объявления шаблона template // фактическое определение шаблона template #include // правильно: Type используется неоднократно в списке параметров шаблона template // правильно: ключевые слова typename и class могут перемежаться template T minus( T*, U ); // ошибка: должно быть // С++ для начинающих 473 В списке параметров шаблона функции ключевые слова typename и class имеют одинаковый смысл и, следовательно, взаимозаменяемы. Любое из них может использоваться для объявления разных параметров-типов шаблона в одном и том же списке (как было продемонстрировано на примере шаблона функции minus()). Для обозначения параметра-типа более естественно, на первый взгляд, употреблять ключевое слово typename, а не class, ведь оно ясно указывает, что за ним следует имя типа. Однако это слово было добавлено в язык лишь недавно, как часть стандарта C++, поэтому в старых программах вы скорее всего встретите слово class. (Не говоря уже о том, что class короче, чем typename, а человек по природе своей ленив.) Ключевое слово typename упрощает разбор определений шаблонов. (Мы лишь кратко остановимся на том, зачем оно понадобилось. Желающим узнать об этом подробнее рекомендуем обратиться к книге Страуструпа “Design and Evolution of C++”.) При таком разборе компилятор должен отличать выражения-типы от тех, которые таковыми не являются; выявить это не всегда возможно. Например, если компилятор встречает в определении шаблона выражение Parm::name и если Parm – это параметр- тип, представляющий класс, то следует ли считать, что name представляет член-тип класса Parm? } Компилятор не знает, является ли name типом, поскольку определение класса, представленного параметром Parm, недоступно до момента конкретизации шаблона. Чтобы такое определение шаблона можно было разобрать, пользователь должен подсказать компилятору, какие выражения включают типы. Для этого служит ключевое слово typename. Например, если мы хотим, чтобы выражение Parm::name в шаблоне функции minus() было именем типа и, следовательно, вся строка трактовалась как объявление указателя, то нужно модифицировать текст следующим образом: } Ключевое слово typename используется также в списке параметров шаблона для указания того, что параметр является типом. Шаблон функции можно объявлять как inline или extern – как и обычную функцию. Спецификатор помещается после списка параметров, а не перед словом template. template Parm minus( Parm* array, U value ) { Parm::name * p; // это объявление указателя или умножение? // На самом деле умножение template Parm minus( Parm* array, U value ) { typename Parm::name * p; // теперь это объявление указателя С++ для начинающих 474 Type min( Array Упражнение 10.1 Определите, какие из данных определений шаблонов функций неправильны. Исправьте ошибки. Ctype foo( Ctype a, Ctype b ); Упражнение 10.2 Какие из повторных объявлений шаблонов ошибочны? Почему? void bar( C1, C2 ); Упражнение 10.3 // правильно: спецификатор после списка параметров template Type min( Type, Type ); // ошибка: спецификатор inline не на месте inline template (a) template (b) template T foo( int *T ); (c) template T1 foo( T2, T3 ); (d) inline template T foo( T, unsigned int* ); (e) template (f) template (g) typedef char Ctype; template (a) template Type bar( Type, Type ); template Type bar( Type, Type ); (b) template С++ для начинающих 475 Перепишите функцию putValues() из раздела 7.3.3 в виде шаблона. Параметризуйте его так, чтобы было два параметра шаблона (для типа элементов массива и для размера массива) и один параметр функции, являющийся ссылкой на массив. Напишите определение шаблона функции. 10.2. Конкретизация шаблона функции Шаблон функции описывает, как следует строить конкретные функции, если задано множество фактических типов или значений. Процесс конструирования называется конкретизацией шаблона. Выполняется он неявно, как побочный эффект вызова или взятия адреса шаблона функции. Например, в следующей программе min() конкретизируется дважды: один раз для массива из пяти элементов типа int, а другой – для массива из шести элементов типа double: } Вызов int i = min( ia ); // определение шаблона функции min() // с параметром-типом Type и параметром-константой size template Type min( Type (&r_array)[size] ) { Type min_val = r_array[0]; for ( int i = 1; i < size; ++i ) if ( r_array[i] < min_val ) min_val = r_array[i]; return min_val; } // size не задан -- ok // size = число элементов в списке инициализации int ia[] = { 10, 7, 14, 3, 25 }; double da[6] = { 10.2, 7.1, 14.5, 3.2, 25.0, 16.8 }; #include { // конкретизация min() для массива из 5 элементов типа int // подставляется Type => int, size => 5 int i = min( ia ); if ( i != 3 ) cout << "??oops: integer min() failed\n"; else cout << "!!ok: integer min() worked\n"; // конкретизация min() для массива из 6 элементов типа double // подставляется Type => double, size => 6 double d = min( da ); if ( d != 3.2 ) cout << "??oops: double min() failed\n"; else cout << "!!ok: double min() worked\n"; return 0; С++ для начинающих 476 приводит к конкретизации следующего экземпляра функции min(), в котором Type заменено на int, а size на 5: } Аналогично вызов double d = min( da ); конкретизирует экземпляр min(), в котором Type заменено на double, а size на 6: В качестве формальных параметров шаблона функции используются параметр-тип и параметр-константа. Для определения фактического типа и значения константы, которые надо подставить в шаблон, исследуются фактические аргументы, переданные при вызове функции. В нашем примере для идентификации аргументов шаблона при конкретизации используются тип ia (массив из пяти int) и da (массив из шести double). Процесс определения типов и значений аргументов шаблона по известным фактическим аргументам функции называется выведением (deduction) аргументов шаблона. (В следующем разделе мы расскажем об этом подробнее. А в разделе 10.4 речь пойдет о возможности явного задания аргументов.) Шаблон конкретизируется либо при вызове, либо при взятии адреса функции. В следующем примере указатель pf инициализируется адресом конкретизированного экземпляра шаблона. Его аргументы определяются путем исследования типа параметра функции, на которую указывает pf: int (*pf)(int (&)[10]) = &min; Тип pf – это указатель на функцию с параметром типа int(&)[10], который определяет тип аргумента шаблона Type и значение аргумента шаблона size при конкретизации min() . Аргумент шаблона Type будет иметь тип int, а значением аргумента шаблона size будет 10. Конкретизированная функция представляется как min(int(&)[10]), и указатель pf адресует именно ее. Когда берется адрес шаблона функции, контекст должен быть таким, чтобы можно было однозначно определить типы и значения аргументов шаблона. Если сделать это не удается, компилятор выдает сообщение об ошибке: int min( int (&r_array)[5] ) { int min_val = r_array[0]; for ( int i = 1; i < 5; ++i ) if ( r_array[i] < min_val ) min_val = r_array[i]; return min_val; template Type min( Type (&p_array)[size] ) { /* ... */ } // pf указывает на int min( int (&)[10] ) |