|
Шаблон классов (class template) в руководствах
программиста иногда называется generic class или
class generator. Шаблон действительно помогает
компилятору сгенерировать определение
конкретного класса по образу и подобию заданной
схемы. Разработчики компилятора C++ различают
два термина: class template и template class.
Первый означает абстрактный шаблон классов, а
второй — одно из его конкретных воплощений.
Пользователь может сам создать template class
для какого-то типа данных. В этом случае
созданный класс отменяет (overrides)
автоматическую генерацию класса по шаблону для
этого типа данных. Рассмотрим стандартный
пример, иллюстрирующий использование шаблона для
автоматического создания классов, которые
реализуют функционирование абстрактного типа
данных «Вектор линейного пространства».
Элементами вектора могут быть объекты различной
природы. В примере создаются векторы целых,
вещественных, объектов некоторого класса circle
(вектор окружностей) и указателей на функции.
Для вектора из элементов любого типа тела
методов шаблона одинаковы, поэтому и есть смысл
объединить их в шаблоне:
#include
<iostream>
#include
<string>
#include
<math.h>
//====== Шаблон классов "Вектор линейного
пространства"
template <class
T> class Vector
{
//====== Данные класса
private:
Т *data; // Указатель начала массива компонентов
int size; // Размер
массива
//====== Методы класса
public:
Vector(int);
~Vector()
{
delete[]
data;
}
int
Size()
{
return
size;
}
T& operator
[](int
i)
{
return
data[i];
}
};
//====== Внешняя реализация тела конструктора
template <class
T> Vector<T>::Vector(int n)
{
data = new
Т[n];
size = n; };
//====== Вспомогательный класс"Круг"
class
Circle
{
private:
//====== Данные класса
int
х, у; // Координаты центра
int
r; // Радиус
public:
//====== Два конструктора
Circle ()
{
х
= у
= r = 0; }
Circle (int a, int b, int
с)
{
x = a;
У = b;
r = с;
}
//====== Метод для вычисления площади круга
double
area ()
{
return
3.14159*r*r;
}
};
//====== Глобальное определение нового типа
//====== указателя на функцию
typedef double
(*Tfunc) (double);
//======
Тестирование
ч
void
main ()
{
//===== Генерируется вектор целых
Vector <int>
x(5) ;
for
( int i=0; i < x.SizeO; ++i)
{
x[i] = i; //
Инициализация
cout
« x[i] « ' ' ; // Вывод
}
cout
« ' \n ' ;
//===== Генерируется вектор
вещественных Vector <float> y(10);
for
(i=0; i < y.SizeO; ++i)
{
y[i] = float (i);
//
Инициализация
cout « y[i] « ' ' ; //
Вывод
}
cout
« ' \n' ;
//==== Генерируется вектор объектов класса
Circle
Vector <Circle> z(4);
for
(i=0; i< z.SizeO; ++i) //
Инициализация
z[i] =
Circle(i+100,i + 100,i+20) ;
cout « z[i].area()
« " "; //
Вывод
}
cout
« ' \n' ;
//==== Генерируется вектор указателей на функции
Vector <Tfunc> f(3);
cout«"\nVector
of function pointers: " ;
f[0] = sqrt; //
Инициализация
f[l] = sin;
f[2] = tan;
for
(i=0; i< f.Size(); ++i)
cout
« f[i](3.) « ' '; //
Вывод
cout « "\n\n";
}
Обратите внимание на синтаксис внешней
реализации тела конструктора шаблона классов.
Vector<T> — это имя шаблона, a Vector (int n) —
имя метода шаблона (конструктор). При
использовании шаблона для генерации конкретного
вектора объектов необходимо задать в угловых
скобках тип данных, известный к этому
моменту и видимый в этой области программы.
Использование шаблона всегда предполагает
наличие описателя типа при имени класса (Vector
<type>). Имя Vector теперь не может быть
использовано без указания конкретного типа
элементов.
В рассмотренном примере операция [ ] определена
в шаблоне как общая для всех типов Т, однако
метоД area () определен только для объектов
класса Circle и он применяется к объекту z [i]
класса circle, вектор из четырех элементов
которого автоматически создается компилятором
при объявлении Vector <circle> z (4);. Работая с
вектором указателей на функции, мы в цикле по
переменой i вызываем i-ю функцию и посылаем ей в
качестве аргумента вещественное число 3 .
Если для какого-то типа переменных автоматически
сгенерированный по шаблону класс не подходит, то
его следует описать явно. Созданный таким
образом класс (template class) отменяет
автоматическое создание класса по шаблону только
для этого типа. Например, предположим, что
создан новый класс Man:
class
Man
{
private:
string m_Name;
int
m_Age;
public:
//=======
Конструкторы
Man{}
{
m_Name = "Dummy";
m_Age = 0; }
Man (char* n, int a)
{
m_Name = string(n);
m_Age = a;
}
Man (strings n, int a)
{
m_Name = n;
m_Age = a;
}
Man&
operator=(const Man&
m)
{
m_Name = m.m_Name;
m_Age = m.m_Age;
return *this;
}
Man(const Man& m)
{
*this = m;
}
//========
Деструктор
~Man()
{
cout
« "\n+ + " « m_Name « " is leaving";
m_Name.erase (); }
bool
operator==(const
Man&
m)
{
return
m_Name == m.m_Name;
}
bool
operator<(const
Mans m)
{
//======= Упорядочиваем по имени
return
m_Name < m.m_Name;
}
friend
ostreams operator«(ostreams os, const
Mans m);
};
//=========
Внешняя реализация операции вывода
ostream&
operator«(ostreams os, const Mans m)
{
return
os « m.m_Name « ", Age: " « m.m_Age;
}
Для класса Man мы не хотим использовать class
template Vector, но хотим со здать вектор
объектов класса, работающий несколько иначе. С
этой целью явн описываем новое конкретное
воплощение (template class) класса Vector дл.
типа Man.
class
Vector <Man>
{
Т
*data;
int
size;
public:
Vector
(int n, T* m);
~Vector 0 { delete [] data;
}
int
Size()
{
return
size;
}
T& operator
[]
(int i)
{
return
data[i];
}
};
Vector <Man> : : Vector (int n, T* m)
{
size = n;
data = new Man [n] ;
for (int
i=0; i<size; i++)
data [i] = m[i] ;
}
Отличие от шаблона состоит в том, что
конструктор класса vector <Man> имеет теперь два
параметра, а не один, как было в шаблоне. Теперь
массив указателей data инициализируется данными
массива объектов, поданного на вход
конструктора. Цель этого нововведения — показать
технику частного воплощения шаблона. Для
проверки функционирования вектора из элементов
типа Man следует создать какой-то тестовый
массив, например:
Man miles ("Miles Davis", 60); //
Отдельный
Man
//====== Массив
объектов класса Man
Man some [ ] =
{
Man("Count Basis",
70),
Man ("Duke Ellingtcnton", 90) ,
miles,
Man("Winton
Marsales", 50) ,
};
а в функцию main ( ) добавить манипуляции с
реальным вектором типа Man. В коде, который
приведен ниже, обратите внимание на то, что при
создании вектора men из четырех объектов класса
Man вторым параметром передается адрес обычного
массива объектов, инициализирующий все элементы
(внутреннего для шаблона) массива data:
//====== Конструируем вектор объектов
//====== на основе массива объектов
Vector <Man> men (sizeof (some) /sizeof (Man) ,
some);
cout«"\nVector
of Man: ";
//======
Вывод вектора
for
(i=0; i< men. Size (); ++i)
cout
« men[i] « "; ";
В шаблоне классов могут быть объявлены static
данные и функции. При этом следует иметь в виду,
что каждый конкретный класс, образованный по
шаблону,
будет иметь свои собственные копии static
членов. Эти члены будут общими для всех объектов
конкретного класса, но различными для всех
классов — реализаций шаблона.
Параметры шаблона
При описании шаблона можно задать более одного
параметра. Например:
template <class
T, int size=256> class Stack
{...};
Теперь при создании конкретной реализации класса
можно задать размер стека
Stack <int, 2048>;
или
Stack <double,
8*N>;
Важно запомнить, что числовой параметр должен
быть константой. В примере переменная N могла
быть описана как const int N=1024; но не могла
быть переменной int N=1024;. При создании
конкретного класса по шаблону возможно вложенное
определение класса, например, если был описан
частный случай класса — шаблон структур вида:
template <class
T> struct Buffer {...};
то после этого можно создать конкретную
структуру, в качестве типа которой задать
структуру, созданную по этому же шаблону,
например:
Buffer <Buffer
<int> >
buf;
Между двумя закрывающими угловыми скобками »
надо вставить символ пробела, так как в языке
C++ операция >> имеет самостоятельный смысл, и
не один. Существует возможность генерировать по
шаблону классы, которые являются производными от
какого-то базового класса. Например, если
описать базовый класс TList, в котором не
определен тип элементов хранения, то есть
используется тип void, то целесообразно ввести
описание шаблона производных классов:
class
TList
//========
Начало списка
void
*First;:
public:
void
insert
(void*);
int
order
(void*, void*, int);
//========
Другие методы
};
template <class
T> class
List :
public
TList T *First;
public:
void
insert (T *t)
{
TList::insert(t);
}
int order (T *pl, T
*p2, int n)
{
return
TList::order(pi, p2, n);
}
//======= Другие методы
};
В этих условиях становится возможным декларация
списка, состоящего из элементов одного
определенного типа, например List <int> intList;,
или гетерогенного списка, состоящего из
элементов различных типов, образованных от
какого-то одного базового класса. Например,
объявление List <Device> DevList; генерирует
класс для работы со списком приборов, из
иерархии классов Device, то есть в списке могут
быть объекты классов, производных от Device.
Аналогичный результат даст объявление List <Man>
ManList; и т. д. Вспомните, что работать с
объектами производных классов можно с помощью
указателей на базовый класс. |
