Вывод типа возвращаемого значения шаблонной функции. Шаблоны
10.1. Определение шаблона функции
Иногда может показаться, что сильно типизированный язык создает препятствия для реализации совсем простых функций. Например, хотя следующий алгоритм функции min() тривиален, сильная типизация требует, чтобы его разновидности были реализованы для всех типов, которые мы собираемся сравнивать:
int min(int a, int b) {
return a b ? a: b;
double min(double a, double b) {
return a b ? a: b;
Заманчивую альтернативу явному определению каждого экземпляра функции min() представляет использование макросов, расширяемых препроцессором:
#define min(a, b) ((a) (b) ? (a) : (b))
Но этот подход таит в себе потенциальную опасность. Определенный выше макрос правильно работает при простых обращениях к min(), например:
min(10.0, 20.0);
но может преподнести сюрпризы в более сложных случаях: такой механизм ведет себя не как вызов функции, он лишь выполняет текстовую подстановку аргументов. В результате значения обоих аргументов оцениваются дважды: один раз при сравнении a и b, а второй – при вычислении возвращаемого макросом результата:
#include iostream
#define min(a,b) ((a) (b) ? (a) : (b))
const int size = 10;
while (min(p++,ia) != ia)
cout "elem_cnt: " elem_cnt
" expecting: " size endl;
На первый взгляд, эта программа подсчитывает количество элементов в массиве ia целых чисел. Но в этом случае макрос min() расширяется неверно, поскольку операция постинкремента применяется к аргументу-указателю дважды при каждой подстановке. В результате программа печатает строку, свидетельствующую о неправильных вычислениях:
elem_cnt: 5 expecting: 10
Шаблоны функций предоставляют в наше распоряжение механизм, с помощью которого можно сохранить семантику определений и вызовов функций (инкапсуляция фрагмента кода в одном месте программы и гарантированно однократное вычисление аргументов), не принося в жертву сильную типизацию языка C++, как в случае применения макросов.
Шаблон дает алгоритм, используемый для автоматической генерации экземпляров функций с различными типами. Программист параметризует все или только некоторые типы в интерфейсе функции (т.е. типы формальных параметров и возвращаемого значения), оставляя ее тело неизменным. Функция хорошо подходит на роль шаблона, если ее реализация остается инвариантной на некотором множестве экземпляров, различающихся типами данных, как, скажем, в случае min().
Так определяется шаблон функции min():
template class Type
Type min2(Type a, Type b) {
return a b ? a: b;
// правильно: min(int, int);
// правильно: min(double, double);
min(10.0, 20.0);
Если вместо макроса препроцессора min() подставить в текст предыдущей программы этот шаблон, то результат будет правильным:
elem_cnt: 10 expecting: 10
(В стандартной библиотеке C++ есть шаблоны функций для многих часто используемых алгоритмов, например для min(). Эти алгоритмы описываются в главе 12. А в данной вводной главе мы приводим собственные упрощенные версии некоторых алгоритмов из стандартной библиотеки.)
Как объявление, так и определение шаблона функции всегда должны начинаться с ключевого слова template, за которым следует список разделенных запятыми идентификаторов, заключенный в угловые скобки " и ", – список параметров шаблона, обязательно непустой. У шаблона могут быть параметры-типы, представляющие некоторый тип, и параметры-константы, представляющие фиксированное константное выражение.
Параметр-тип состоит из ключевого слова class или ключевого слова typename, за которым следует идентификатор. Эти слова всегда обозначают, что последующее имя относится к встроенному или определенному пользователем типу. Имя параметра шаблона выбирает программист. В приведенном примере мы использовали имя Type, но могли выбрать и любое другое:
template class Glorp
Glorp min2(Glorp a, Glorp b) {
return a b ? a: b;
При конкретизации (порождении конкретного экземпляра) шаблона вместо параметра-типа подставляется фактический встроенный или определенный пользователем тип. Любой из типов int, double, char*, vectorint или listdouble является допустимым аргументом шаблона.
Параметр-константа выглядит как обычное объявление. Он говорит о том, что вместо имени параметра должно быть подставлено значение константы из определения шаблона. Например, size – это параметр-константа, который представляет размер массива arr:
template class Type, int size
Type min(Type (arr) );
Вслед за списком параметров шаблона идет объявление или определение функции. Если не обращать внимания на присутствие параметров в виде спецификаторов типа или констант, то определение шаблона функции выглядит точно так же, как и для обычных функций:
template class Type, int size
/* параметризованная функция для отыскания
* минимального значения в массиве */
Type min_val = r_array;
for (int i = 1; i size; ++i)
if (r_array[i] min_val)
min_val = r_array[i];
В этом примере Type определяет тип значения, возвращаемого функцией min(), тип параметра r_array и тип локальной переменной min_val; size задает размер массива r_array. В ходе работы программы при использовании функции min() вместо Type могут быть подставлены любые встроенные и определенные пользователем типы, а вместо size – те или иные константные выражения. (Напомним, что работать с функцией можно двояко: вызвать ее или взять ее адрес).
Процесс подстановки типов и значений вместо параметров называется конкретизацией шаблона. (Подробнее мы остановимся на этом в следующем разделе.)
Список параметров нашей функции min() может показаться чересчур коротким. Как было сказано в разделе 7.3, когда параметром является массив, передается указатель на его первый элемент, первая же размерность фактического аргумента-массива внутри определения функции неизвестна. Чтобы обойти эту трудность, мы объявили первый параметр min() как ссылку на массив, а второй – как его размер. Недостаток подобного подхода в том, что при использовании шаблона с массивами одного и того же типа int, но разных размеров генерируются (или конкретизируются) различные экземпляры функции min().
Имя параметра разрешено употреблять внутри объявления или определения шаблона. Параметр-тип служит спецификатором типа; его можно использовать точно так же, как спецификатор любого встроенного или пользовательского типа, например в объявлении переменных или в операциях приведения типов. Параметр-константа применяется как константное значение – там, где требуются константные выражения, например для задания размера в объявлении массива или в качестве начального значения элемента перечисления.
// size определяет размер параметра-массива и инициализирует
// переменную типа const int
template class Type, int size
Type min(const Type (r_array))
const int loc_size = size;
Type loc_array;
Если в глобальной области видимости объявлен объект, функция или тип с тем же именем, что у параметра шаблона, то глобальное имя оказывается скрытым. В следующем примере тип переменной tmp не double, а тот, что у параметра шаблона Type:
typedef double Type;
template class Type
Type min(Type a, Type b)
// tmp имеет тот же тип, что параметр шаблона Type, а не заданный
// глобальным typedef
Type tm = a b ? a: b;
Объект или тип, объявленные внутри определения шаблона функции, не могут иметь то же имя, что и какой-то из параметров:
template class Type
Type min(Type a, Type b)
// ошибка: повторное объявление имени Type, совпадающего с именем
// параметра шаблона
typedef double Type;
Type tmp = a b ? a: b;
Имя параметра-типа шаблона можно использовать для задания типа возвращаемого значения:
// правильно: T1 представляет тип значения, возвращаемого min(),
// а T2 и T3 – параметры-типы этой функции
template class T1, class T2, class T3
В одном списке параметров некоторое имя разрешается употреблять только один раз. Например, следующее определение будет помечено как ошибка компиляции:
// ошибка: неправильное повторное использование имени параметра Type
template class Type, class Type
Type min(Type, Type);
Однако одно и то же имя можно многократно применять внутри объявления или определения шаблона:
// правильно: повторное использование имени Type внутри шаблона
template class Type
Type min(Type, Type);
template class Type
Type max(Type, Type);
Имена параметров в объявлении и определении не обязаны совпадать. Так, все три объявления min() относятся к одному и тому же шаблону функции:
// все три объявления min() относятся к одному и тому же шаблону функции
// опережающие объявления шаблона
template class T T min(T, T);
template class U U min(U, U);
// фактическое определение шаблона
template class Type
Type min(Type a, Type b) { /* ... */ }
Количество появлений одного и того же параметра шаблона в списке параметров функции не ограничено. В следующем примере Type используется для представления двух разных параметров:
// правильно: Type используется неоднократно в списке параметров шаблона
template class Type
Type sum(const vectorType , Type);
Если шаблон функции имеет несколько параметров-типов, то каждому из них должно предшествовать ключевое слово class или typename:
// правильно: ключевые слова typename и class могут перемежаться
template typename T, class U
// ошибка: должно быть typename T, class U или
// typename T, typename U
template typename T, U
В списке параметров шаблона функции ключевые слова typename и class имеют одинаковый смысл и, следовательно, взаимозаменяемы. Любое из них может использоваться для объявления разных параметров-типов шаблона в одном и том же списке (как было продемонстрировано на примере шаблона функции minus()). Для обозначения параметра-типа более естественно, на первый взгляд, употреблять ключевое слово typename, а не class, ведь оно ясно указывает, что за ним следует имя типа. Однако это слово было добавлено в язык лишь недавно, как часть стандарта C++, поэтому в старых программах вы скорее всего встретите слово class. (Не говоря уже о том, что class короче, чем typename, а человек по природе своей ленив.)
Ключевое слово typename упрощает разбор определений шаблонов. (Мы лишь кратко остановимся на том, зачем оно понадобилось. Желающим узнать об этом подробнее рекомендуем обратиться к книге Страуструпа “Design and Evolution of C++”.)
При таком разборе компилятор должен отличать выражения-типы от тех, которые таковыми не являются; выявить это не всегда возможно. Например, если компилятор встречает в определении шаблона выражение Parm::name и если Parm – это параметр-тип, представляющий класс, то следует ли считать, что name представляет член-тип класса Parm?
template class Parm, class U
Parm::name * p; // это объявление указателя или умножение?
// На самом деле умножение
Компилятор не знает, является ли name типом, поскольку определение класса, представленного параметром Parm, недоступно до момента конкретизации шаблона. Чтобы такое определение шаблона можно было разобрать, пользователь должен подсказать компилятору, какие выражения включают типы. Для этого служит ключевое слово typename. Например, если мы хотим, чтобы выражение Parm::name в шаблоне функции minus() было именем типа и, следовательно, вся строка трактовалась как объявление указателя, то нужно модифицировать текст следующим образом:
template class Parm, class U
Parm minus(Parm* array, U value)
typename Parm::name * p; // теперь это объявление указателя
Ключевое слово typename используется также в списке параметров шаблона для указания того, что параметр является типом.
Шаблон функции можно объявлять как inline или extern – как и обычную функцию. Спецификатор помещается после списка параметров, а не перед словом template.
// правильно: спецификатор после списка параметров
template typename Type
Type min(Type, Type);
// ошибка: спецификатор inline не на месте
template typename Type
Type min(ArrayType, int);
Упражнение 10.1
Определите, какие из данных определений шаблонов функций неправильны. Исправьте ошибки.
(a) template class T, U, class V
void foo(T, U, V);
(b) template class T
(c) template class T1, typename T2, class T3
(d) inline template typename T
T foo(T, unsigned int*);
(e) template class myT, class myT
void foo(myT, myT);
(f) template class T
(g) typedef char Ctype;
template class Ctype
Ctype foo(Ctype a, Ctype b);
Упражнение 10.2
Какие из повторных объявлений шаблонов ошибочны? Почему?
(a) template class Type
Type bar(Type, Type);
template class Type
Type bar(Type, Type);
(b) template class T1, class T2
void bar(T1, T2);
template typename C1, typename C2
void bar(C1, C2);
Упражнение 10.3
Перепишите функцию putValues() из раздела 7.3.3 в виде шаблона. Параметризуйте его так, чтобы было два параметра шаблона (для типа элементов массива и для размера массива) и один параметр функции, являющийся ссылкой на массив. Напишите определение шаблона функции.
Из книги Microsoft Office автора Леонтьев Виталий ПетровичВыбор шаблона Как мы уже говорили, Publisher рассчитан на работу в «пошаговом» режиме – мы как бы собираем будущую публикацию по кусочкам. А еще точнее – создаем ее на основе одного из бесчисленных шаблонов. На компакт-диске с Publisher хранится более полутора тысяч шаблонов
Из книги Справочное руководство по C++ автора Страустрап БьярнR.7.1.4 Спецификация шаблона типа Спецификация шаблона типа используется для задания семейства типов или функций (см.
Из книги Эффективное делопроизводство автора Пташинский Владимир СергеевичПонятие шаблона Для упрощения работы по созданию и форматированию текстов, стандартизации расположения и оформления текста, графики, типизации операций обработки документов и прочего используются шаблоны документов. Пакет Microsoft Office дает различные определения шаблона
Из книги Обработка баз данных на Visual Basic®.NET автора Мак-Манус Джеффри П Из книги Создание шаблонов Joomla автора Автор неизвестенСтруктура директорий шаблона Теперь необходимо позаботится о кое-каких условиях. Как уже говорилось, шаблон должен иметь определенную структуру директорий:[ПутьКJoomla!]/templates/[НазваниеШаблона]/[ПутьКJoomla!]/templates/[ НазваниеШаблона]/css/[ПутьКJoomla!]/templates/[
Из книги XSLT автора Хольцнер СтивенСтруктура шаблона Помимо специального заголовка, для шаблона необходима структура. Создать структуру можно при помощи таблиц или тегов
Создание шаблона
В главе 2 для выбора узлов в planets.xml и преобразования этого документа в HTML я создал основной шаблон. Шаблоны в таблицах стилей создаются при помощи элементов
Тело шаблона Фактически, элемент xsl:template, определяющий шаблонное правило, задает не более чем условия, при которых это правило должно выполняться. Конкретные же действия и инструкции, которые должны быть исполнены, определяются содержимым элемента xsl:template и составляют
Из книги Язык Си - руководство для начинающих автора Прата СтивенОпределение функции Определение функции специфицирует имя, формальные параметры и тело функции. Оно может также специфицировать тип возвращаемого значения и класс памяти функции. Синтаксис определения функции следующий:[<спецификация КП>][<спецификация
Из книги Недокументированные и малоизвестные возможности Windows XP автора Клименко Роман АлександровичОпределение функции с аргументом: формальные аргументы Определение нашей функции начинается с двух строк: space(number)int number;Первая строка информирует компилятор о том, что у функции space() имеется аргумент и что его имя number. Вторая строка - описание, указывающее
Из книги Как сделать свой сайт и заработать на нем. Практическое пособие для начинающих по заработку в Интернете автора Мухутдинов ЕвгенийСоздание шаблона безопасности Чтобы создать шаблон безопасности на основе любого другого шаблона, необходимо в контекстном меню шаблона выбрать команду Сохранить как. Затем консоль управления Microsoft предложит вам указать имя нового шаблона, после чего он отобразится в
Из книги C++ для начинающих автора Липпман Стенли Из книги автора10.2. Конкретизация шаблона функции Шаблон функции описывает, как следует строить конкретные функции, если задано множество фактических типов или значений. Процесс конструирования называется конкретизацией шаблона. Выполняется он неявно, как побочный эффект вызова
Из книги автора Из книги автора10.11. Пример шаблона функции В этом разделе приводится пример, показывающий, как можно определять и использовать шаблоны функций. Здесь определяется шаблон sort(), который затем применяется для сортировки элементов массива. Сам массив представлен шаблоном класса Array (см.
Из книги автора16.1. Определение шаблона класса Предположим, что нам нужно определить класс, поддерживающий механизм очереди. Очередь - это структура данных для хранения коллекции объектов; они помещаются в конец очереди, а извлекаются из ее начала. Поведение очереди описывают
Вы можете создать прототип шаблона функции в виде его предварительного объявления. Такое объявление информирует компилятор о наличии шаблона, а также сообщает об ожидаемых параметрах. Например, прототип шаблона функции Sort будет выглядеть так:
template
Имена формальных параметров шаблона могут не совпадать в предварительном объявлении и определении шаблона. Так, например, в следующем фрагменте и прототип шаблона, и определение шаблона относятся к одной и той же функции:
template
template
Type max(Type a, Type b)
if (a > b) return a; else return b;
Использование шаблона функции
Шаблон функции описывает, как конкретная функция может быть построена на основании одного или нескольких фактических типов. Компилятор автоматически создает представитель тела функции для указанных в вызове типов. Такой процесс называется конкретизацией . Он происходит при вызове шаблонной функции.
Например, в следующем примере функция min() конкретизируется дважды: один раз типом int и один раз типом double:
template
Type min(Type a, Type b)
if (a < b) return a; else return b;
int x = 4, y = 5, z;
double t = 6.56, r = 3.07, p;
Специализация шаблонов функции
Специализированная функция шаблона – это обычная функция, имя которой совпадает с именем функции в шаблоне, но которая определяется для параметров специфических типов. Специализированные функции шаблона определяют в том случае, когда обобщенный шаблон не годится для некоторого типа данных. Например, функция шаблона min
template
Type min(Type a, Type b)
if (a < b) return a; else return b;
не может применяться для строк (для типа char*) , так как генерируемый компилятором код будет просто сравнивать их положение в памяти (адреса). Для корректного сравнения строк можно определить специализированную функцию:
char* min(char* s1, char* s2)
if (strcmp(s1,s2)>0) return s2; else return s1;
Тогда обращаться к такой функции можно так же, как и к функции шаблона:
int i1 = 3, i2 = 5;
cout << “max int = ” << max(i1, i2) << endl;
char* s1 = “Golden Eagle”;
char* s2 = “Perigrine Falcon”;
cout << “max str = “ << max(s1, s2) << endl;
Шаблоны классов
Шаблон класса дает обобщенное определение семейства классов, использующее произвольные типы или константы. Шаблон определяет данные-члены шаблона и функции-члены шаблона . После определения шаблона класса можно предписать компилятору генерировать на его основе новый класс для конкретного типа или константы.
Синтаксис шаблона класса
template <<список аргументов шаблона>>
class <имя класса>
<тело класса>
За ключевым словом template следуют один или несколько аргументов (параметров), заключенных в угловые скобки и отделяемых друг от друга запятыми. Каждый аргумент может представлять собой ключевое слово class, за которым следует идентификатор, обозначающий параметризованный тип. Список аргументов шаблона не может быть пустым.
Затем следует определение класса. Оно аналогично определению обычного класса, за исключением того, что использует список аргументов шаблона.
Параметры шаблона, состоящие из ключевого слова class и следующего за ним идентификатора, часто называют параметрами типа . Другими словами, они информируют компилятор, что шаблон предполагает тип в качестве аргумента.
Мы уже ранее рассматривали в С++ такой инструмент, как шаблоны, когда создавали . Почему стоит пользоваться шаблонами, было написано в статье, с шаблонами функций. Там мы рассмотрели основные положения шаблонов в С++. Давайте их вспомним.
Любой шаблон начинается со слова template , будь то шаблон функции или шаблон класса. После ключевого слова template идут угловые скобки — < > , в которых перечисляется список параметров шаблона. Каждому параметру должно предшествовать зарезервированное слово class или typename . Отсутствие этих ключевых слов будет расцениваться компилятором как . Некоторые примеры объявления шаблонов:
Template
Template
Template
Ключевое слово typename говорит о том, что в шаблоне будет использоваться встроенный тип данных, такой как: int , double , float , char и т. д. А ключевое слово class сообщает компилятору, что в шаблоне функции в качестве параметра будут использоваться пользовательские типы данных, то есть классы. Но не в коем случае не путайте параметр шаблона и шаблон класса. Если нам надо создать шаблон класса, с одним параметром типа int и char , шаблон класса будет выглядеть так:
Template
где T — это параметр шаблона класса, который может принимать любой из встроенных типов данных, то, что нам и нужно.
А если параметр шаблона класса должен пользовательского типа, например типа Array , где Array — это класс, описывающий массив, шаблон класса будет иметь следующий вид:
Template
C этим вам лучше разобраться изначально, чтобы потом не возникало никаких ошибок, даже, если шаблон класса написан правильно.
Давайте создадим шаблон класса Стек, где , в которой хранятся однотипные элементы данных. В стек можно помещать и извлекать данные. Добавляемый элемент в стек, помещается в вершину стека. Удаляются элементы стека, начиная с его вершины. В шаблоне класса Stack необходимо создать основные методы:
- Push — добавить элемент в стек;
- Pop — удалить элемент из стека
- printStack — вывод стека на экран;
Итак реализуем эти три метода, в итоге получим самый простой класс, реализующий работу структуры стек. Не забываем про конструкторы и деструкторы. Смотрим код ниже.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
#include
Как видите шаблон класса Stack объявлен и определен в файле с main -функцией. Конечно же такой способ утилизации шаблонов никуда не годится, но для примера сойдет. В строках 7 — 20 объявлен интерфейс шаблона класса. Объявление класса выполняется привычным для нас образом, а перед классом находится объявление шаблона, в строке 7. При объявлении шаблона класса, всегда используйте такой синтаксис.
Строки 47 — 100 содержат элемент-функции шаблона класса Stack, причем перед каждой функцией необходимо объявлять шаблон, точно такой же, как и перед классом — template
Чтобы привязать каждую элемент-функцию к шаблону класса, как обычно используем бинарную операцию разрешения области действия — :: с именем шаблона класса — Stack
Обратите внимание на объявление объекта myStack шаблона класса Stack в функции main , строка 24. В угловых скобочка необходимо явно указывать используемый тип данных, в шаблонах функций этого делать не нужно было. Далее в main запускаются некоторые функции, которые демонстрируют работу шаблона класса Stack . Результат работы программы смотрим ниже.
Заталкиваем элементы в стек: 12 3456 768 5 4564 |4564 | 5 | 768 |3456 | 12 Удаляем два элемента из стека: | 0 | 0 | 768 |3456 | 12
Шаблоны функций, своими словами,- это инструкции, согласно которым создаются локальные версии шаблонированной функции для определенного набора параметров и типов данных.
На самом деле, шаблоны функций -это мощный инструмент в С++, который намного упрощает труд программиста. Например, нам нужно запрограммировать функцию, которая выводила бы на экран элементы массива. Задача не сложная! Но, чтобы написать такую функцию, мы должны знать тип данных массива, который будем выводить на экран. И тут нам говорят — тип данных не один, мы хотим, чтобы функция выводила массивы типа int , double , float и char .
Как оказалось, задача усложнилась. И теперь мы понимаем, что нам нужно запрограммировать целых 4 функции, которые выполняют одни и те же действия, но для различных типов данных. Так как мы еще не знакомы с шаблонами функций, мы поступим так: воспользуемся .
// перегрузка функции printArray для вывода массива на экран void printArray(const int * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const double * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const float * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const char * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; }
Таким образом, мы имеем 4 перегруженные функции, для разных типов данных. Как видите, они отличаются только заголовком функции, тело у них абсолютно одинаковое. Я написал один раз тело функции для типа int и три раза его скопировал для других типов данных.
И, если запустить программу с этими функциями, то она будет исправно работать. Компилятор сам будет определять какую функцию использовать при вызове.
Как видите, кода получилось достаточно много, как для такой простой операции. А что если, нам понадобится запрограммировать в виде функции. Получается, что для каждого типа данных придется свою функцию создавать. То есть, сами понимаете, что один и тот же код будет в нескольких экземплярах, нам это ни к чему. Поэтому в С++ придуман такой механизм - шаблоны функций.
Мы создаем один шаблон, в котором описываем все типы данных. Таким образом исходник не будет захламляться никому ненужными строками кода. Ниже рассмотрим пример программы с шаблоном функции. Итак, вспомним условие: «запрограммировать функцию, которая выводила бы на экран элементы массива».
// код Code::Blocks
// код Dev-C++
#include
Заметьте, код уменьшился в 4 раза, так как в программе объявлен всего один экземпляр функции - шаблон. В main я объявил несколько массивов - четыре, для типов данных: int , double , float , char . После чего, в строках 26, 28, 30, 32, выполняется вызов функции printArray для разных массивов. Результат работы программы показан ниже.
Шаблон функции вывода массива на экран Массив типа int: 1 2 3 4 5 6 7 8 9 10 Массив типа double: 1.2345 2.234 3.57 4.67876 5.346 6.1545 7.7682 Массив типа float: 1.34 2.37 3.23 4.8 5.879 6.345 73.434 8.82 9.33 10.4 Массив типа char: M A R S
Как видите программа корректно работает, и для этого нам понадобилось всего один раз определить функцию printArray в привычном для нас виде. Обратите внимание, что перед объявлением самой функции, в строке 5, стоит следующая запись template
Все шаблоны функций начинаются со слова template , после которого идут угловые скобки, в которых перечисляется список параметров. Каждому параметру должно предшествовать зарезервированное слово class или typename .
Template
Template
Template
Ключевое слово typename говорит о том, что в шаблоне будет использоваться встроенный тип данных, такой как: int , double , float , char и т. д. А ключевое слово class сообщает компилятору, что в шаблоне функции в качестве параметра будут использоваться пользовательские типы данных, то есть классы.
У нас в шаблоне функции использовались встроенные типы данных, поэтому в строке 5 мы написали template
// шаблон функции printArray
template
В строке 2 выполняется определение шаблона с одним параметром - T , причем этот параметр будет иметь один из встроенных типов данных, так как указано ключевое слово typename .
Ниже, в строках 3 — 8 объявлена функция, которая соответствует всем критериям объявления обычной функции, есть заголовок, есть тело функции, в заголовке есть имя и параметры функции, все как обычно. Но что эту функции превращает в шаблон функции, так это параметр с типом данных T , это единственная связь с шаблоном, объявленным ранее. Если бы мы написали
Void printArray(const int * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; }
то это была бы простая функция для массива типа int .
Так вот, по сути T - это даже не тип данных, это зарезервированное место под любой встроенный тип данных. То есть когда выполняется вызов этой функции, компилятор анализирует параметр шаблонированной функции и создает экземпляр для соответственного типа данных: int , char и так далее.
Поэтому следует понимать, что даже если объем кода меньше, то это не значит, что памяти программа будет потреблять меньше. Компилятор сам создает локальные копии функции-шаблона и соответственно памяти потребляется столько, как если бы вы сами написали все экземпляры функции, как в случае с перегрузкой.
Надеюсь основную мысль по шаблонам функций до вас довел. Для закрепления материала, давайте рассмотрим еще один пример программы, с использованием шаблона функции.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
#include
Вот вам еще один пример использования шаблонов функций. Шаблон функции объявлен в строках 5-13. Функция должна возвращать максимальное значение массива, поэтому возвращаемое значение типа T , ведь тип данных массива заранее не известен. Кстати внутри функции объявлена переменная max типа T , в ней будет храниться максимальное значение массива. Как видите, тип данных T используется не только для спецификации параметров функции, но и для указания типа возвращаемого значения, а также может свободно использоваться для объявления любых переменных внутри шаблона функции.
Максимальный элемент массива типа char: s Максимальный элемент массива типа int: 9
Шаблоны функций также можно перегружать другими шаблонами функций, изменив количество передаваемых параметров в функцию. Еще одной особенностью перегрузки является то, что шаблонные функции могут быть перегружены обычными не шаблонными функциями. То есть указывается то же самое имя функции, с теми же параметрами, но для определенного типа данных, и все будет корректно работать.
Собрался я было писать текст про всякие крутые структуры данных и тут оказалось, что мы ещё не разбирали несколько очень важных возможностей C++. Шаблоны - одна из них.
Шаблоны (templates) - очень мощное средство. Шаблонные функции и классы позволяют очень сильно упростить программисту жизнь и сберечь огромное количество времени, сил и нервов. Если вам покажется, что шаблоны не сильно-то и значимая тема для изучения, знайте - вы заблуждаетесь.
Шаблонные функции
Простой пример шаблонной функции:
код на языке c++ Type square (Type a) { Type b; b = a*a; return b; } int x = 5; int i; i = square(5); float y = 0.5; float f; f = square(y);
Если бы мы создавали функции по старинке, то тогда бы пришлось писать две разные функции: для типа int и для типа float. А если бы понадобилась такая же функция, использующая другие типы, пришлось бы заново писать и её. Используя шаблоны, можно ограничиться только одним экземпляром функции, оставив всю грязную работу компилятору.
Вместо использования какого-то определённого типа, в функции используется параметрический тип (или по другому - аргумент шаблона). Здесь я обозвал параметрический тип идентификатором Type. В функции этот идентификатор встречается три раза: возвращаемое значение, аргумент функции и определение переменной s. То есть Type используется как любой обычный тип.
Но чтобы код заработал, перед функцией нужно добавить следующую строку (я показал несколько вариантов синтаксиса, все они рабочие):
код на языке c++
template
Итак, перед функцией должно стоять ключевое слово template (шаблон), а в угловых скобках нужно указать имя параметрического типа с ключевым словом class. Вместо ключевого слова class можно использовать type - в общем-то никакой разницы.
Идентификатор параметрического типа тоже может быть любым. Мы часто будем пользоваться вот такими: TypeA, TypeB, Datatype, T.
Важное замечание : У шаблонных функций должен быть аргумент, чтобы компилятор мог определить какой именно тип использовать.
В шаблонах можно использовать несколько параметрических типов, и конечно же можно смешивать параметрические типы со стандартными (только нужно позаботиться о правильном приведении типов). Приведу пример в котором используется два параметрических типа TypeA, TypeB и базовый тип int:
код на языке c++
template
Но шаблонные функции - не самое интересное, что мы сегодня рассмотрим.
Шаблонные классы
В общем-то шаблонные классы создаются почти так же как и шаблонные функции - перед именем класса записывается ключевое слово template. Шаблонные классы рассмотрим на примере стека:
код на языке c++
template
делили стек из десяти элементов. Эти элементы могут быть какого угодно типа, об этом чуть-чуть ниже.
Единственное на что хочу обратить ваше внимание: определение функций push и pop. Функция push определена внутри класса, а функция pop - снаружи. Для всех функции объявлённых за пределами класса, нужно обязательно указывать ключевое слово template. Выражение перед именем функции совпадает с тем, которое указывается перед именем класса.
Теперь посмотрим как работать с шаблонными классами:
код на языке c++
stack
При создании объекта, после имени класса нужно поставить угловые скобки, в которых указать нужный тип. После этого объекты используются так, как мы привыкли.
У шаблонных классов есть одна потрясающая особенность - кроме стандартных типов, они могут работать и с пользовательскими. Рассмотрим небольшой пример. Для этого определим простой класс warrior:
код на языке c++
class warrior
{
public:
int health;
warrior () : health(0) {}
};
stack
Смотрите, теперь в стеках можно размещать переменные типа warrior!!! Возможно вы не поверите мне, но это очень круто! Насколько это круто, вы сможете убедиться когда на основе списков мы будем создавать графы и деревья.
По шаблонам пока всё. Позже разберём более сложные случаи использования шаблонных классов.