Классы

Пример 1:

Написать программу, в которой создается класс Student. Формируется динамический массив объектов. При тестировании выводится: сформированный список студентов, список студентов заданного факультета, список студентов для заданных факультета и курса.

Решение от преподавателя:

#include

#include

#include

struct date // дата рождения

{char daymon[6];

int year; };

class Student{

char name[30]; //private

date t;

char adr[30], fac[20];

int kurs;

public:

Student();

char *getfac();

int getkurs();

void show();

};

Student::Student()

{cout<<"Input name:"; cin>>name;

cout<<"Input date of born\n";

cout<<"Day.mon:"; cin>>t.daymon;

cout<<"Year:"; cin>>t.year;

cout<<"Input adr:"; cin>>adr;

cout<<"Input fac:"; cin>>fac;

cout<<"Input kurs:"; cin>>kurs;

}

void Student::show()

{

cout<<"Name :"<

cout<<"Was born :"<

cout<<"Address :"<

cout<<"Fac :"<

cout<<"Kurs :"<

}

char *Student::getfac() { return fac; }

int Student::getkurs() { return kurs; }

void spisfac(Student spis[],int n)//список студентов заданного факультетата

{char fac[20];

cout<<"Input faculty:"; cin>>fac;

for(int i=0;i

if(strcmp(spis[i].getfac(),fac)==0)spis[i].show();

}

void spisfackurs(Student spis[],int n)

//список студентов заданных факультета и курса

{int i,k;

char fac[20];

cout<<"Input faculty:"; cin>>fac;

cout<<"Input the course:"; cin>>k;

for(i=0;i

if ((strcmp(spis[i].getfac(),fac)==0)&&(spis[i].getkurs()==k))

spis[i].show();

}

void main()

{ Student *spis;

int n;

cout<<"Input a number of students: "; cin>>n;

spis=new Student [n];

for(int i=0;i

cout<<"=============================="<

spis[i].show();

}

spisfac(spis,n);

spisfackurs(spis,n);

delete [] spis;

cout<<"press any key!"

while(!kbhit());

}

Пример 2:

Создается класс Polynom. В головной программе выполняется тестирование класса.

Решение от преподавателя:

#include

#include

#include

class Polynom {

int n;

double *koef;

public:

Polynom(); //конструкторы

Polynom(int k);

Polynom(int k,double *mas);

Polynom(const Polynom&ob); //конструктор копирования

~Polynom(){delete[]koef;}

void GiveMemory(int k);

void SetPolynom(int k,double *mas);

void SetDegree(int k){n=k;}; //установить степень

void CalculateValue(double x); //вычислить значение

int GetDegree(){return n;}; //получить степень

double GetOneCoefficient(int i){return(koef[i]);};

Polynom operator+(Polynom ob); //перегрузка операторов

Polynom operator*(Polynom ob);

double& operator[](int i){return(koef[i]);}//перегрузка []

Polynom& operator = (const Polynom p) {

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

if(koef) delete [] koef;

n=p.n;

koef=new double [p.n+1];

for(int i=0;i<=p.n;i++)

koef[i]=p.koef[i];

return *this;

}

friend ostream& operator<<(ostream& mystream,Polynom &ob);

friend istream& operator>>(istream& mystream,Polynom &ob);

int min(int n,int m)

{return (n

int max(int n,int m)

{return (n>m)? n:m; }

};

//*********** Polynom() **********************************

Polynom::Polynom()

{ randomize();

n=random(5);

koef=new double[n+1];

if(!koef){cout<<"Error";getch();return;}

for(int i=n;i>=0;i--)

koef[i]=random(10)-5;

}

//************* Polynom(int k) *******************************

Polynom::Polynom(int k)

{ n=k;

koef=new double[n+1];

if(!koef){cout<<"Error";getch();return;}

for(int i=n;i>=0;i--)

koef[i]=random(10)-5;

}

//****************** Polynom(int k,double mas[]) ******************

Polynom::Polynom(int k,double mas[])

{n=k;

koef=new double[n+1];

if(!koef){cout<<"Error";getch();return;}

for(int i=n;i>=0;i--)

koef[i]=mas[i];

}

//*************** Polynom(const Polynom&ob) *********************

Polynom::Polynom(const Polynom&ob)

{n=ob.n;

koef=new double[n+1];

if(!koef){cout<<"Error";getch();return;}

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

koef[i]=ob.koef[i];

}

//**************** void GiveMemory(int k) **********************

void Polynom::GiveMemory(int k)

{

if(koef) delete [] koef;

koef=new double[k+1];

if(!koef){cout<<"Error";getch();return;}

}

//******************** SetPolynom **************************

void Polynom::SetPolynom(int k,double *mas)

{ n=k;

if(koef) delete [] koef;

koef = new double [n+1];

for(int i=n;i>=0;i--)

koef[i]=mas[i];

}

//*************** CalculateValue *****************************

void Polynom::CalculateValue(double x=1.0)

{ double s;

int i;

for(s=koef[0],i=1;i<=n;i++)

s=s+koef[i]*pow(x,i);

cout<<"f("<

}

//**************** Polynom operator+(Polynom ob) ***************

Polynom Polynom::operator+(Polynom ob)

{ int i;

Polynom rab;

rab.GiveMemory(max(n,ob.GetDegree()));

for(i=0;i<=min(n,ob.GetDegree());i++)

rab.koef[i]=koef[i]+ob.GetOneCoefficient(i);

if(n

{

for(i=min(n,ob.GetDegree())+1;i<=ob.GetDegree();i++)

rab.koef[i]=ob.GetOneCoefficient(i);

rab.n=ob.GetDegree();

}

else

{

for(i=min(n,ob.GetDegree())+1;i<=n;i++) rab.koef[i]=koef[i];

rab.n=n;

}

return rab;

}

//*************** Polynom operator*(Polynom ob) ***************

Polynom Polynom::operator*(Polynom ob)

{

int i,j,k;

double s;

Polynom rab;

rab.GiveMemory(n+ob.GetDegree());

for(i=0;i<=n+ob.GetDegree();i++)

{ s=0;

for(j=0;j<=n;j++)

for(k=0;k<=ob.GetDegree();k++)

if(j+k==i)s=s+koef[j]*ob.GetOneCoefficient(k);

rab.koef[i]=s;

}

rab.n=n+ob.GetDegree();

return rab;

}

//********** ostream& operator<<(ostream& mystream,Polynom &ob) ******

ostream& operator<<(ostream& mystream,Polynom &ob)

{ char c=' '; //пропустим “+” перед первым коэффициентом

for(int i=ob.n;i>=0;i--)

{ double ai=ob.koef[i];

if(ai==0) continue;

else {if(ai>0) mystream<

if(i==0) continue; else mystream<<"x";

if(i==1) continue; else mystream<<"^"<

if(ai!=0)c='+';

}

if(c==' ')mystream<<0;

mystream<

return mystream;

}

//********* istream& operator>>(istream& mystream,Polynom &ob) *

istream& operator>>(istream& mystream,Polynom &ob)

{

int i;

cout<<"Enter Degree:"; mystream>>ob.n; cout<

for(i=ob.n;i>=0;i--)

{

cout<<"Enter koeff "<>ob.koef[i];

}

return mystream;

}

//******************** MAIN ****************************

int main(int argc, char* argv[])

{ const int m=3;

Polynom f,g,masp[m],*p1,s;

int n=5,i;

double K[6]={1.0,3.2,0.0,4.1,0.0,1.1};

p1=new Polynom(n,K);

cout<<*p1;

p1->CalculateValue(2.0);

cin>>f;

cout<<" f(x)= "; cout<

cout<<" g(x)= "; cout<

s=f+g;

cout<<"f(x)+g(x) = "; cout<

s=f*g;

cout<<" f(x)*g(x) = "; cout<

s=masp[0]; cout<

for(i=1;i

{ s=s+masp[i]; cout<

cout<<"Summa: "; cout<< s;

while(!kbhit());

delete p1;

return 0;

}

Пример 3:

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

Решение от преподавателя:

#include"vip\menu.cpp" //реализация работы с меню

#include

#include

#include

char bufRus[256];

char*Rus(const char*text){

CharToOem(text,bufRus);

return bufRus;}

struct node

{

int n; //информационное поле узла дерева

int count;

node*left,*right;

};

class Tree

{

public:

node*root;

Tree(){root=0;}

Tree(int t); // Формирование дерева из t случайных чисел

void CopyTree(node*&rootnew,node*rootold);

/* Копирует дерево с корнем rootold в дерево с корнем rootnew. В результате деревья находятся в различных динамических участках памяти.*/

Tree(const Tree&ob); //конструктор копирования

// Рекурсивная функция, используемая в деструкторе (освобождение памяти)

void DelTree(node *wer);

~Tree(){DelTree(root);}

void Push(node*&wer,int data);// Вставка элемента в дерево

void Look(node*wer); //- Вывод дерева на экран

node*Find(node*wer,int key); // Поиск по ключу

void PrintLeaves(node *wer); // Вывод листьев дерева на экран

};

//********************** Tree::Tree(int t) *******************

Tree::Tree(int t)

{

root=0;

for(int i=0;i

Push(root,random(10)-5);

}

void Tree::CopyTree(node*&rootnew,node*rootold)

{

if(rootold->left!=0)

{Push(rootnew,(rootold->left)->n);CopyTree(rootnew,rootold->left);}

if(rootold->right!=0)

{Push(rootnew,(rootold->right)->n);CopyTree(rootnew,rootold->right);}

}

Tree::Tree(const Tree&ob)

{

if(ob.root==0)root=0;

else {

root=new node;

root->n=ob.root->n;

root->count=1;

root->left=0;

root->right=0;

CopyTree(root,ob.root);

}

}

void Tree::DelTree(node *wer)

{

if(wer->left!=0)DelTree(wer->left);

if(wer->right!=0)DelTree(wer->right);

delete wer;

}

void Tree::Push(node*&wer,int data)

{

if(wer==0)

{

wer=new node;

wer->n=data;

wer->left=0;wer->right=0;

wer->count=1;

}

else if(datan)Push(wer->left,data);

else if(data>wer->n)Push(wer->right,data);

else wer->count++;

}

void Tree::Look(node*wer)

{

if(wer!=0)

{

Look(wer->left);

cout<n<<" - "<count;

cout<

Look(wer->right);

}

}

node* Tree::Find(node*wer,int key)

{

if(wer==0) return 0;

else if(keyn) return Find(wer->left,key);

else if(key>wer->n) return Find(wer->right,key);

else return wer;

}

void Tree::PrintLeaves(node *wer)

{

if(wer==0)return;

else if( (wer->left==0)&&(wer->right==0) ) {

cout<n<<”-“<count;

cout<

}

else

{

PrintLeaves(wer->left);

PrintLeaves(wer->right);

}

}

//-------------------------------- MAIN ----------------------------------------

int main(int argc, char* argv[])

{

Tree tr;

node *u;

int k=0,max,kol;

char menu[][100]={ {" PushElement "}, {" ShowTree "}, {" FindElement "},

{" PrintLeaves "}, {" EXIT "}, };

kol=5;//КОЛИЧЕСТВО СТРОК МЕНЮ. Используется в выравнивании строк

// меню по центру.

//------------------ВЫРАВНИВАНИЕ СТРОК МЕНЮ ПО ЦЕНТРУ----------------

max=viravnivaniestrok(menu,kol);

//------------------------ МЕНЮ НА ЭКРАНЕ---------------------------------------

textmode(C80);

while(1){

switch(mmm(kol,menu,max,k))

{ case 0: {

int data;

cout<

cin>>data;

tr.Push(tr.root,data);

k=0;break;

}

case 1: {

if(tr.root==0)cout<

else

{

cout<

tr.Look(tr.root);

}

while(!kbhit());

k=1;break;

}

case 2: {

if(tr.root==0)cout<

else

{

int key;

cout<

cin>>key;

if((u=tr.Find(tr.root,key))!=0){

cout<

cout<

cout<

cout<count<

}

else cout<

}

while(!kbhit());

k=2;break;

}

case 3: {

if(tr.root==0)cout<

else{

cout<

tr.PrintLeaves(tr.root);

}

while(!kbhit());

k=3;break;

}

case 4:{

exit(0);

}

} }

return 0;

}