Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
Скачиваний:
76
Добавлен:
10.12.2013
Размер:
52.74 Кб
Скачать

Министерство Образования Российской Федерации

Пермский Государственный Технический Университет

Кафедра ИТАС

Лабораторная работа № 6

ШАБЛОНЫ ФУНКЦИЙ И КЛАССОВ

Вариант №3

Выполнил: Студент

группы АСУ 04-2

Заколодкин К.А.

Проверил: Ноткин А.М.

Пермь 2005

Постановка задачи

Создать шаблон класса - множество. Определить конструкторы, деструктор, перегруженную операцию присваивания (“=”) и следующие операции:

-  удалить элемент из множества.

>  проверка на подмножество.

!=  проверка множеств на неравенство.

Определить пользовательский класс Библиотека, объекты которого содержат данные о названии книги, авторе, цене.

Определение шаблона и пользовательского класса

template <class Stype> class Set

{

Stype* beg;

int len;

int max_s;

public:

Set();

Set(int);

~Set();

Set(const Set&);

void Insert (int,Stype*);

void PrintStan();

void PrintUser();

Set& operator=(const Set& );

bool operator>(Set&);

void operator-(Stype);

bool operator!=(Set&);

bool ToBe(Stype);

};

//------------------------------------------------------------------------

class BIBL

{

char name[20];

char autor[20];

double price;

public:

BIBL ();

BIBL (char*,char*,double);

BIBL (const BIBL&);

~BIBL ();

void Set(char*,char*,double);

void Show();

bool operator ==(BIBL);

bool operator !=(BIBL);

};

Реализации

template <class Stype> Set<Stype>::Set()

{

beg=new Stype [max_s=MAX];

len=0;

}

//------------------------------------------------------------------------

template <class Stype> Set<Stype>::Set(int t)

{

max_s=t;

beg=new Stype [max_s];

len=0;

}

//------------------------------------------------------------------------

template <class Stype> Set<Stype>::~Set()

{ delete[] beg; }

template <class Stype> Set<Stype>::Set(const Set& Obj)

{

delete[] beg;

len=Obj.len;

beg=new Stype [len];

for(int i=0;i<len;i++)

beg[i]=Obj.beg[i];

}

//------------------------------------------------------------------------

template <class Stype> void Set<Stype>::Insert (int n,Stype* type)

{

if(n>max_s) Rus(" Неверное кол-во элементов \n");

else

{

len=n;

for(int i=0;i<len;i++)

beg[i]=type[i];

}

}

//------------------------------------------------------------------------

template <class Stype> void Set<Stype>::PrintStan()

{

if(!len) Rus("Пустое множество \n");

else

Rus(" Множество : ");cout<<endl;

for(int i=0;i<len;i++)

cout<<*(beg+i)<<endl;

}

//------------------------------------------------------------------------

template <class Stype> void Set<Stype>::PrintUser()

{

if(!len) Rus("Пустое множество \n");

else

Rus(" Множество : ");cout<<endl;

for(int i=0;i<len;i++)

beg[i].Show();

}

//------------------------------------------------------------------------

template <class Stype> Set<Stype>& Set<Stype>::operator=(const Set& Obj)

{

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

delete[] beg;

len=Obj.len;

beg=new Stype [len];

for(int i=0;i<len;i++)

beg[i]=Obj.beg[i];

return *this;

}

//------------------------------------------------------------------------

template <class Stype> bool Set<Stype>::operator>(Set& Obj)

{

int Len=0;

if(len<Obj.len) return false;

for(int i=0;i<len;i++)

{

if(ToBe(Obj.beg[i])) Len++;

}

if (Len==Obj.len) return true;

return false;

}

//------------------------------------------------------------------------

template <class Stype> void Set<Stype>::operator -(Stype c)

{

int i,j=0;

len-=1;

Stype* t=new Stype[len];

for(i=0;i<len+1;i++)

{

if(beg[i]!=c)

{

t[j]=beg[i];

j++;

}

}

delete[] beg;

beg=t;

}

//------------------------------------------------------------------------

template <class Stype> bool Set<Stype>::operator!=(Set& Obj)

{

if(len!=Obj.len) return true;

for(int i=0;i<len;i++)

{if(beg[i]!=Obj.beg[i]) return true;}

return false;

}

//------------------------------------------------------------------------

template <class Stype> bool Set<Stype>::ToBe(Stype c)

{

Stype* t=this->beg;

for(int i=0;i<len;i++)

if(t[i]==c) return true;

return false;

}

BIBL::BIBL ()

{

strcpy(name,Oem("═σ≥ Φ∞σφΦ"));

strcpy(autor,Oem("═σ≥ Φ∞σφΦ"));

price=0;

}

//------------------------------------------------------------------------

BIBL::BIBL(char* Name,char* Autor,double Price)

{

strcpy(name,Oem(Name));

strcpy(autor,Oem(Autor));

price=Price;

}

//------------------------------------------------------------------------

BIBL::BIBL(const BIBL& a)

{

strcpy(name,a.name);

strcpy(autor,a.autor);

price=a.price;

}

//------------------------------------------------------------------------

BIBL::~BIBL(){}

//------------------------------------------------------------------------

void BIBL::Set(char* Name,char* Autor,double Price)

{

strcpy(name,Oem(Name));

strcpy(autor,Oem(Autor));

price=Price;

}

//------------------------------------------------------------------------

void BIBL::Show()

{

cout<<Oem("╚∞ :")<<name<<endl;

cout<<Oem("└Γ≥ε≡:")<<autor<<endl;

cout<<Oem("╓σφα")<<price<<endl;

}

//------------------------------------------------------------------------

bool BIBL::operator ==(BIBL b)

{

if(strcmp(name,b.name)!=0) return false;

if(strcmp(autor,b.autor)!=0) return false;

if(price!=b.price) return false;

return true;

}

bool BIBL::operator !=(BIBL b)

{

if(strcmp(name,b.name)==0 && strcmp(autor,b.autor)==0 && price==b.price) return false;

return true;

}

Функция main

void main()

{

Set<char> A(4);

Set<double> B(4);

Set<BIBL> C(2);

Set<char> A1(4);

Set<double> B1(4);

Set<BIBL> C1(2);

char a[3]={'a','b','c'};

double b[3]={3.14,4.15,5.16};

BIBL c[2];

c[0].Set("Книга1","Автор1",111);

c[1].Set("Книга2","Автор2",222);

char a1[3]={'a','b'};

double b1[3]={3.14,4.15};

BIBL c1[2];

c1[0].Set("Книга1","Автор1",111);

c1[1].Set("Книга2","Автор2",222);

A.Insert(3,a);

B.Insert(3,b);

C.Insert(2,c);

A1.Insert(2,a1);

B1.Insert(2,b1);

C1.Insert(2,c1);

if(A>A1) Rus("A1 подмножество A \n");

if(B>B1) Rus("B1 подмножество B \n");

if(C>C1) Rus("C1 подмножество C \n");

if(A!=A1) Rus("A не равно A1 \n");

if(B!=B1) Rus("B не равно B1 \n");

if(C!=C1) Rus("C не равно C1 \n");

A-a[0];

B-b[0];

C-c[0];

A.PrintStan();

B.PrintStan();

C.PrintUser();

}

Результат работы

A1 подмножество A

B1 подмножество B

C1 подмножество C

A не равно A1

B не равно B1

Множество :

b

c

Множество :

4.15

5.16

Множество :

Имя:Книга2

Автор:Автор2

Цена222

Press any key to continue

Соседние файлы в папке Lab_6