Е. К. Пугачев Объектно-ориентированное программирование Под общей редакцией Ивановой Г. С. Рекомендовано Министерством общего и профессионального образования Российской Федерации в качестве учебник

Вид материала

Содержание

3.8.Параметризованные классы
Параметризованный класс
Пример 3.63. Шаблон, позволяющий формировать одномерные динамические массивы из заданных элементов
Пример 3.64. Использование шаблонов для формирования массивов и печати их элементов
Шаблон функции
Пример 3.65. Использование шаблонов функций при создании шаблонов классов
Пример 3.66. Использование шаблона классов (шаблон классов «Множество»)
Tset(int number)
Tset& CrossSet(Tset &B)

Подобный материал:

1 ... 19 20 21 22 23 24 25 26 ... 39

3.8.Параметризованные классы

В С++ предусмотрена реализация еще одного типа полиморфизма - параметризованные классы и параметризованные функции.

^ Параметризованный класс – это некий шаблон (template), на основе которого можно строить другие классы. Этот шаблон следует рассматривать как описание множества классов, моделирующих абстрактную структуру данных и отличающихся типами полей, включенных в эту структуру. Хорошим примером параметризированных классов могут служить шаблоны реализации списков, массивов, множеств и т.п. Шаблон классов определяет правила построения каждого отдельного класса из множества разрешенных (допустимых) классов. Описание шаблона выглядит так:

template <список параметров шаблона> <описание класса>

В списке параметров шаблона могут присутствовать как параметры, определяющие тип, так и параметры, для которых этот тип фиксирован. Каждый формальный параметр, определяющий тип, обозначается ключевым словом class.

^ Пример 3.63. Шаблон, позволяющий формировать одномерные динамические массивы из заданных элементов

template // объявление шаблона с аргументом «type»

class array // начало описания класса с именем array

{ type * contents; // указатель на динамический массив типа type

int size; // размер массива

public:

array(int number) {contents = new type [size=number];}

~array (){delete [] contents;}

type & operator [] (int x) // переопределение операции []

{ if ((x<0)||(x>=size)) { cerr << “ошибочный индекс”; x=0;}

return contents[x];

}

} // конец описания класса с именем array

Используя шаблон, можно определить объекты класса array с аргументом любого допустимого типа. Допустимым являются как встроенные типы языка, так и типы, определенные пользователем.

Формат определения объекта одного из классов, порождаемых шаблоном, выглядит следующим образом:

имя_параметризованного_класса <список_параметров_шаблона>

имя_объекта (параметры_конструктора)

Например, для шаблона классов, описанного в примере 3.34 можно определить следующие объекты:

array int_a(50); // объект-массив с элементами целого типа

array char_a(100); // объект-массив с элементами типа char

array float_a(30); // объект-массив с элементами типа float

Описание шаблона можно записать в файл с расширением «h» и, используя его стандартным образом, определять объекты заданного множества классов, а также выполнять операции над этими объектами.

^ Пример 3.64. Использование шаблонов для формирования массивов и печати их элементов

#include «array.h»

#include

#include

#include

void main()

{ int i;

array int_a(5);

array char_a(5);

for (i=0;i<5;i++) // определение компонент массивов

{int_a[i]=random(20); char_a[i]:=’A’+i;}

puts(“компоненты массива”);

for (i=0;i<5;i++)

{cout << “ “<< int_a[i]<< “ “ <

}

Функции параметризованного класса можно определить и вне описания класса, но следует учитывать, что функции являются параметризованными и их надо описывать как функции – шаблоны (параметризованные функции), например:

template type & array ::operator[](int x) /* заголовок функции – шаблона*/

{ if ((x<0)||(x>=size)) { cerr << «ошибочный индекс»;x=0;}

return contents[x]; }

Параметризованная функция. Помимо шаблона классов разрешается определять также шаблоны функций. ^ Шаблон функции - это глобальная функция, определенная за пределами классов. В отличие от перегрузки функции, при которой для каждой сигнатуры создается своя функция, шаблон семейства функций определяется один раз, но это описание содержит параметры. Для задания параметров используется список.

Описание шаблона функции:

template <список параметров шаблона> <описание функции>

Каждый формальный параметр обозначается ключевым словом class, за которым следует имя параметра (идентификатор). Например, описание шаблона функции, возвращающей значение максимальной из двух переменных, выглядит следующим образом:

template type max(type x, type y){ return(x>y)?x:y;}

Использование шаблона функций позволяет передать в функцию в качестве параметра тип используемых в ней данных, а далее выполнять операции, предусмотренные алгоритмом над объектами заданных типов. Если для некоторых типов объектов операции, используемые в функции, не определены, следует ввести явное описание функции для этого типа. Например, при использовании шаблона из предыдущего описания, если в качестве аргумента будут использованы строки, то, так как операция «>» для строк не определена, функция выдаст не правильный результат. Для того чтобы в качестве параметра шаблона можно было использовать строки, следует добавить явное описание функции-оператора «>» для строк.

^ Пример 3.65. Использование шаблонов функций при создании шаблонов классов

#include

#include

#include

template T max(T x, T y)

{ return(x>y)?x:y;}

char * max(char * x, char * y) /* описание функции для объектов типа строка */

{return strcmp(x,y) > 0? x:y;}

void main ()

{ clrscr();

int a=1,b=2; char c='a', d='m'; float e=123.675, f=456;

char str[]="abcd", str2[]="abnd";

//вызов функции для объектов различного типа

cout << "Integer max= "<// Integer max= 2

cout << "Character max= "< // Character max= m

cout << "Float max= "< // Float max= 456

cout << "String max= "< // String max= abnd

getch();

}

Примечание. Каждый аргумент шаблона функций должен определять тип как минимум одного аргумента описываемой функции. Это гарантирует, что нужный вариант функции будет выбран на основе анализа типов ее аргументов. Отмеченное правило не распространяется на шаблоны классов.

Рассмотрим обобщенный пример использования шаблонов классов при моделировании структуры типа «множество».

^ Пример 3.66. Использование шаблона классов (шаблон классов «Множество»)

Пусть необходимо разработать шаблон классов для реализации объектов типа множество. Шаблон должен обеспечивать возможность выполнения следующих операций: построения множества из заданных элементов, добавления элементов, удаления элементов, пересечения множеств, объединения множеств, присвоения множеств и проверки вхождения элемента во множество.

Для корректной работы с множеством доступ к его элементам осуществляется с помощью внутренних функций. Чтобы присвоение одного объекта другому происходило с освобождением памяти, выделенной под значения полей объекта приемника, предусмотрена переопределенная операция присваивания. Типовые операции над множествами реализованы несколькими способами: через дружественные внешние операции-функции, компонентные операции и в виде обычных компонентных функций. Так как возможна инициализация объекта другим объектом-множеством, предусмотрен копирующий конструктор.

Шаблон описывает правила выполнения всех указанных выше операций относительно параметра type (рис. 3.5).

Рис. 3.49. Структура классов для примера 3.37

Примечание. Этот пример можно рассматривать как иллюстрацию использования объектов с динамическими полями, учитывающий некоторые особенности таких объектов.

Тестирующая программа объявляет объект класса Множество с элементами типа char и проверяет выполнение всех операций.

#include

#include

#include

template // объявление шаблона с аргументом type

class Tset

{ private:

type *contents; // указатель на динамический массив типа type

int size; // размер множества при инициализации

int sizetek; //текущий размер множества

int SetEl(int ind,type m) // функция записи элемента в массив

{ if (ind

else {cout<<" размер множества превышен"<

type GetEl(int ind) // функция чтения элемента из массива

{ return contents[ind];}

public:

Tset(){ cout<<" конструктор по умолчанию "<

Tset(Tset &A); // прототип копирующего конструктора

^ Tset(int number) // конструктор класса Tset

{ cout<<" конструктор"<

contents = new type [size=number];sizetek=0;}

~Tset () // деструктор

{ cout<<" деструктор"<

int Getsize() //определение максимального размера множества

{return size;}

void Add(type m); // добавление элемента ко множеству

void Del(type m); // удаление элемента из множества

int In(type m); // проверка вхождения элемента во множество

int InSet(int Nn); // заполнение множества

void OutSet(); // вывод элементов множества

^ Tset& CrossSet(Tset &B); // пересечение множеств

Tset &operator +(Tset &B); // объединение множеств

Tset &operator =(Tset &B); // присвоение множеств

friend Tset &operator *(Tset &A,Tset &B); // пересечение множеств

friend Tset &operator -(Tset &A,Tset &B); // дополнение множеств

};

template Tset::Tset(Tset&A)

{ cout<<" Копирующий конструктор"<

contents = new type [size=A.Getsize()];

sizetek=A.sizetek;

for(int i=0;i

template int Tset::InSet(int Nn)

{ type c; int k=0;

if (Nn>Getsize()) Nn=Getsize();

cout<<"Введите "<

for (int i=0;i

{ cin>>c; if (!In(c)){if(!SetEl(k,c)) return 0;k+=1;}}

return 1; }

template void Tset::OutSet()

{ cout<<" Содержимое множества: "<

if (sizetek!=0) {for(int i=0;i

else cout<<" Пустое множество";

cout<

template int Tset::In(type m)

{ for (int i=0;i

return 0; }

template void Tset::Add(type m)

{if (!In(m)) if (sizetek

template void Tset::Del(type m)

{ int h;

if (In(m)) { h=0;

for(int i=0;i

if(h) contents[i-1]=contents[i];

else if (m==GetEl(i)) h=1;

sizetek-=1; }

}

template Tset

& Tset::operator =(Tset &B)

{ cout<<" Операция присваивания "<

if (this==&B) return *this;

if (contents!=NULL) delete [] contents;

contents = new type [size=B.Getsize()];

sizetek=B.sizetek;

for(int i=0;i

return *this; }

template Tset

& Tset::operator +(Tset &B)

{ for(int i=0;i

template Tset

&Tset::CrossSet(Tset &B)

{ int i=0;

do {if( !B.In(GetEl(i))) Del(GetEl(i)); else i++;}

while (i

return *this; }

template Tset

& operator -(Tset &A,Tset &B)

{ Tset *C=new Tset(A.Getsize());

for(int i=0;iAdd(A.GetEl(i));

return *C; }

template Tset

& operator *(Tset&A,Tset &B)

{ int l;

if(A.Getsize() > B.Getsize()) l=A.Getsize(); else l=B.Getsize();

Tset *C=new Tset(l);

for(int i=0;i

{if( B.In(A.GetEl(i))) C->Add(A.GetEl(i));}

return *C; }

void main()

{int n; clrscr();

Tset aa(15),bb(10),dd(10),cc;

cout<<"Введите число членов формируемого множества n<= ";

cout<<aa.Getsize()<>n; aa.InSet(n);

cout<<"Введите число членов формируемого множества n<= ";

cout<<bb.Getsize()<<endl; cin>>n; bb.InSet(n);

cout<<"Введите число членов формируемого множества n<= ";

cout<>n; dd.InSet(n);

clrscr();

cout<<" Множество aa "<aa.OutSet();

cout<<" Множество bb "<bb.OutSet();

cout<<" Множество dd "<dd.OutSet();

Tset ee=aa*bb; // инициализировать объект уже созданным

cout<<" Пересечение множеств aa и bb"<

aa.CrossSet(bb);

cout<<" Пересечение множеств aa и bb компонентное"<

aa.OutSet();

aa=aa+dd;

cout<<" Объединение множеств аа и dd"<

cc=dd-bb;

cout<<" Дополнение множеств dd и bb"<

cc=dd; // явная операция присвоения

cc.OutSet();

getch();

}

Тестирующая программа осуществляет формирование трех множеств букв и операции над ними, а также фиксирует последовательность и место вызова конструкторов различного назначения и деструкторов.

Blog

Содержание

3.8.Параметризованные классы