Шаблоны классов

Шаблон классов (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 (см. вызов f [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; и т. д. Вспомните, что работать с объектами производных классов можно с помощью указателей на базовый класс.

Содержание раздела