#include <stdio.

h>
#include <string.h>
#include <stdlib.h>
#include <iostream.h>
#include <conio.h>
#define maxx 50
template <class element> class multime
{
public:
multime <element> operator+(multime
mi
multime <element> operator*(multime
multimi
multime <element> operator-(multime
etrica intre doua multimi
multime <element> operator<(multime
ta unei multimi la cealalta multime

<element>); // se reunesc doua multi

<element>); // se intersecteaza doua
<element>); // se face diferenta sim
<element>); // se verifica apartenen

int operator+(element); // se adauga un element la o multime

int operator-(int);
// se extrage un element dintr-o multime
int operator*(element); //se verifica apartenenta unui element la o mult
ime
multime(int); //constructor de multime vida
multime();
multime(multime <element> &); //constructor de copiere
friend ostream& operator<<(ostream&,multime <element>&); //operatii de i
esire
friend istream& operator>>(istream&,multime <element> &); //operatii de
intrare
void sortare(); // sorteaza crescator elementele unei multimi
void afisare(); //se afiseaza continutul unei multimi
~multime(); //destructor
private:
element *pv; // pointer la primul element al multimii
int nr_elem; // cardinalul multimii
int index;
};
template <class element> multime <element>::multime()
{
pv=new element[maxx];
nr_elem=maxx;
index=0;
}
/////////////////////////////////////////////////////////////////////////
//////////////////// CONSTRUCTOR DE COPIERE /////////////////////////
/////////////////////////////////////////////////////////////////////////
template <class element> multime <element>::multime(multime <element> &v)
{
int max,i;

max=v.nr_elem;
pv=new element[max];
nr_elem=max;
index=v.index;
for (i=0;i<index;i++)
pv[i]=v.pv[i];
}
///////////////////////////////////////////////////////////////////
///////////////// CONSTRUCTOR DE MULTIME VIDA /////////////////
///////////////////////////////////////////////////////////////////
template <class element> multime <element>::multime(int i)
{
nr_elem=i;
pv=new element[nr_elem];
index=0;
}
//////////////////////////////////////////////////////
////////////////// DESTRUCTOR ////////////////////
template <class element> multime <element>::~multime()
{
delete[] pv;
}
/////////////////////////////////////////////////////////////////////
/////////// ADAUGAREA UNUI ELEMENT IN MULTIME ///////////////////
/////////////////////////////////////////////////////////////////////
template <class element> int multime <element>::operator+(element val)
{
int er=0;
if(index==nr_elem)
{
cout<<"Nu mai e loc in multime!!!";
return 0;
}
else
for (int i=0;i<nr_elem;i++)
{
if (pv[i]==val)
{
er=1;
cout<<"Multimea contine deja aceasta valoare!";
return 0;
}
}
if (!er)
{
pv[index]=val;
index++;
return 1;
}
return 0;
}
////////////////////////////////////////////////////////////////

////////// EXTRAGEREA UNUI ELEMENT DIN MULTIME /////////////

////////////////////////////////////////////////////////////////
template <class element> int multime <element>::operator-(int i)
{
if(i<0 && i>index) return 0;
else
{
for (int j=i;j<index;j++)
pv[j]=pv[j+1];
index--;
return 1;
}
}
//////////////////////////////////////////////////////////////////////
/////////////// APARTENENTA UNUI ELEMENT LA O MULTIME ////////////
//////////////////////////////////////////////////////////////////////
template <class element> int multime <element>::operator*(element val)
{
int er=0;
for (int i=0;i<nr_elem;i++)
{
if (pv[i]==val)
{
er=1;
cout<<"Multimea contine aceasta valoare!";
return 1;
}
}
if (!er)
{
cout<<"Multimea nu contine aceasta valoare!";
return 0;
}
return 0;
}
//////////////////////////////////////////////////////////////////////
/////////////// APARTENENTA UNEI MULTIMI LA O MULTIME ////////////
//////////////////////////////////////////////////////////////////////
template <class element> multime <element> multime <element>::operator<(multime
<element> v)
{
bool vb;
bool er=true;
int i=0;
while (i<index)
{
vb=false;
for (int j=0;j<v.index;j++)
if (v.pv[i]==pv[j])
vb=true;
i++;
if (!vb)
er=false;

}
if (!er)
{
cout<<"Prima multime nu este inclusa in cea de-a
doua !";
return 0;
}
else
{
cout<<"Prima multime este inclusa in cea de-a do
ua !";
return 1;
}
}
////////////////////////////////////////////////////////////////////////////////
////////////
//////////////////////////// REUNIUNEA A DOUA MULTIMI //////////////////////
////////////
////////////////////////////////////////////////////////////////////////////////
////////////
template <class element> multime <element> multime <element>::operator+(multime
<element> v)
{
int max;
bool vb;
int i,j;
int k;
max=index+v.index;
multime <element> rez(max);
for (i=0;i<index;i++)
rez.pv[i]=pv[i];
i=0;
rez.index=index;
k=index;
while(i<v.index)
{
vb=true;
for (j=0;j<index;j++)
if (v.pv[i]==rez.pv[j]) vb=false;
if (vb)
{
rez.pv[k]=v.pv[i];
k++;
}
i++;
}
rez.index=k;
return rez;
}
////////////////////////////////////////////////////////////////////////////////
////////////
//////////////////////////// INTERSECTIA A DOUA MULTIMI ////////////////////
////////////

////////////////////////////////////////////////////////////////////////////////
////////////
template <class element> multime <element> multime <element>::operator*(multime
<element> v)
{
multime <element> rez;
int i=0,k=0,l=0;
bool vb=true;
while (i<index)
{
for(int j=0;j<v.index;j++)
if (pv[i]==v.pv[j]) vb=false;
if (!vb)
{
rez.pv[k]=pv[i];
k++;
}
i++;
vb=true;
}
rez.index=k;
return rez;
}
////////////////////////////////////////////////////////////////////////////////
////////////
//////////////////////////// DIFERENTA A DOUA MULTIMI //////////////////////
////////////
////////////////////////////////////////////////////////////////////////////////
////////////
template <class element> multime <element> multime <element>::operator-(multime
<element> v)
{
multime <element> rez;
int i=0,k=0,l=0;
bool vb=true;
while (i<index)
{
for(int j=0;j<v.index;j++)
if (pv[i]==v.pv[j]) vb=false;
if (vb)
{
rez.pv[k]=pv[i];
k++;
}
vb=true;
i++;
}
rez.index=k;
return rez;
}
//////////////////////////////////////////////////////////
/////////////// SE SORTEAZA O MULTIME ////////////////
//////////////////////////////////////////////////////////
template <class element> void multime <element>::sortare()
{

int i,j;
element aux;
for (i=0;i<index-1;i++)
for (j=i;j<index;j++)
if (pv[i]>pv[j])
{ aux=pv[i];
pv[i]=pv[j];
pv[j]=aux;
}
}
//////////////////////////////////////////////////////////
/////// SE AFISEAZA ELEMENTELE UNEI MULTIMI //////////
//////////////////////////////////////////////////////////
template <class element> void multime <element>::afisare()
{
int i;
if (index==0)
cout<<"Multimea vida!!!";
else
for (i=0;i<index;i++)
cout<<pv[i]<<endl;
}
template <class element> ostream& operator<<(ostream& s,multime <element> &v)
{
v.afisare();
return s;
}
/////////////////////////////////////////////////////////////////////////////
///////////////////// SE INCARCA ELEMENTELE IN MULTIME //////////////////
/////////////////////////////////////////////////////////////////////////////
template <class element> istream& operator>>(istream &s,multime <element> &v)
{
int n;
element x;
cout<<"Dati numarul de elemente al multimii: ";
cin>>n;
for(int i=0;i<n;i++)
{
cout<<"Elementul "<<i+1<<" este: ";
cin>>x;
(v+x);
}
return s;
}

////////////////////////////////////////////////////////////////////////////////
/////
///////////////// PARTICULARIZARE PENTRU O MULTIME DE PERSOANE /////////////
/////
////////////////////////////////////////////////////////////////////////////////
/////

class persoana
{
int varsta;
char nume[20];
float salariu;
friend class multime;
friend ostream &operator<<(ostream &,persoana &); //operatii de iesir
e
friend istream &operator>>(istream &,persoana &); //operatii de intrare
public:
bool operator>(persoana &);
bool operator==(persoana &);
persoana (int v=0,float s=0,char n[20]="Anonim")
{
strcpy(nume,n);
varsta=v;
salariu=s;
}
};
///////////////////////////////////////////////
/// SE AFISEAZA ELEMENTELE UNEI MULTIMI ///
///////////////////////////////////////////////
ostream &operator<<(ostream &k,persoana &p)
{
cout<<"\n";
k<<p.nume;
cout<<" are varsta ";
k<<p.varsta;
cout<<" si salariul ";
k<<p.salariu;
return k;
}
//////////////////////////////////////////////
//// SE INCARCA ELEMENTELE UNEI MULTIMI ////
//////////////////////////////////////////////
istream &operator>>(istream &k,persoana &p)
{
cout<<"\n";
cout<<"Introduceti numele persoanei:";
k>>p.nume;
cout<<"Introduceti varsta persoanei:";
k>>p.varsta;
cout<<"Introduceti salariul persoanei:";
k>>p.salariu;
cout<<"\n";
return k;
}
bool persoana::operator==(persoana &p)
{
if (strcmp(nume,p.nume)<=0)
if (p.salariu==salariu)

if(p.varsta==varsta)
return true;
return false;
}
bool persoana::operator>(persoana &p)
{
if ((varsta>=18)&&(varsta<=35)&&(p.varsta>=18)&&(p.varsta<=35))
{if (varsta>p.varsta) return true;}
else
{if(salariu>p.salariu) return true;}
return false;
}
void meniu()
{
system("cls");
cout<<"\n
BILET NR. 17 - CLASA TEMPLATE MULTIME\n";
cout<<"\n1) Testare pe multime de numere";
cout<<"\n2) Testare pe multime de persoane";
cout<<"\n3) Iesire\n";
cout<<"\nDati optiunea:";
}
void submeniu1()
{
system("cls");
cout<<"\n
TESTARE PE MULTIME DE NUMERE \n";
cout<<"\n1) Introducere elemente in cele doua multimi";
cout<<"\n2) Sortarea celor doua multimi";
cout<<"\n3) Testarea apartenentei primei multimi la cea de-a doua";
cout<<"\n4) Reuniunea celor doua multimi";
cout<<"\n5) Intersectia celor doua multimi";
cout<<"\n6) Diferenta simetrica dintre cele doua multimi";
cout<<"\n7) Adaugarea unui element in prima multime";
cout<<"\n8) Extragerea unui element din prima multime";
cout<<"\n9) Testarea apartenentei unui element la prima multime";
cout<<"\n10) Iesire\n";
cout<<"\nDati optiunea:";
}
void submeniu2()
{
system("cls");
cout<<"\n
TESTARE PE MULTIME DE PERSOANE \n";
cout<<"\n1) Introducere elemente in cele doua multimi";
cout<<"\n2) Sortarea celor doua multimi";
cout<<"\n3) Testarea apartenentei primei multimi la cea de-a doua";
cout<<"\n4) Reuniunea celor doua multimi";
cout<<"\n5) Intersectia celor doua multimi";
cout<<"\n6) Diferenta simetrica dintre cele doua multimi";
cout<<"\n7) Adaugarea unui element in prima multime";
cout<<"\n8) Extragerea unui element din prima multime";
cout<<"\n9) Testarea apartenentei unui element la prima multime";
cout<<"\n10) Iesire\n";
cout<<"\nDati optiunea:";
}

void main()
{
multime <int> t(20),x(20);
int val;
int i;
int opt,opt1,opt2;
multime <persoana> v1(6),v2(6);
persoana val1;
meniu();
cin>>opt;
while (opt!=3)
{
switch(opt)
{
case 1: submeniu1();
cin>>opt1;
while (opt1!=10)
{
switch(opt1)
{
case 1:
system("cls");
cin>>t;
cout<<"Multimea
este:\n";
t.afisare();
cin>>x;
cout<<"Multimea
este:\n";
x.afisare();
getch();
break;
case 2:
system("cls");
/// SE SORTEAZA ELEMENTE
LE MULTIMII t SI SE AFISEAZA REZULTATUL ///
t.sortare();
cout<<"Multimea
sortata este:\n";
t.afisare();
/// SE SORTEAZA ELEMENTE
LE MULTIMII x SI SE AFISEAZA REZULTATUL ///
x.sortare();
cout<<"Multimea
sortata este:\n";
x.afisare();
getch();
break;
case 3:
/// SE TESTEAZA APARTENE
NTA MULTIMII t LA MULTIMEA x ///

(t<x);
cout<<"\n\n\n\n\
n";
break;
case 4:
system("cls");
/// SE REUNESTE MULTIMEA
t CU MULTIMEA x ///
cout<<"\nCele do
ua multimi se reunesc !\n";
cout<<"Multimea
devine:\n";
(t+x).afisare();
getch();
break;
case 5:
system("cls");
/// SE INTERSECTEAZA MUL
TIMEA t CU MULTIMEA x ///
cout<<"\nCele do
ua multimi se intersecteaza !\n";
cout<<"Multimea
devine:\n";
(t*x).afisare();
getch();
break;
case 6:
system("cls");
/// SE FACE DIFERENTA SI
METRICA DINTRE MULTIMEA t SI MULTIMEA x ///
cout<<"\nSe face
diferenta celor doua multimi !\n";
cout<<"Multimea
devine:\n";
(t-x).afisare();
getch();
break;
case 7:
system("cls");
/// SE ADAUGA ELEMENTUL
val IN MULTIMEA t ///
cout<<"\nDati el
ementul pe care doriti sa-l inserati in prima multime:";
cin>>val;
(t+val);
cout<<"\nMultime
a devine:\n";
t.afisare();
getch();
break;
case 8:
system("cls");
/// SE EXTRAGE DIN MULTI
MEA t ELEMENTUL DE PE POZITIA i ///
cout<<"\nDati po

zitia elementului pe care doriti sa-l stergeti din prima multime:";

cin>>i;
(t-i);
cout<<"\nMultime
a devine:\n";
t.afisare();
getch();
break;
case 9:
system("cls");
/// SE VERIFICA APARTENE
NTA ELEMENTULUI val LA MULTIMEA t ///
cout<<"\nDati el
ementul pe care doriti sa-l cautati in multime:";
cin>>val;
(t*val);
cout<<"\n\n\n\n\
n";
break;
}
system("cls");
submeniu1();
cin>>opt1;
}
break;
case 2:
submeniu2();
cin>>opt2;
while (opt2!=10)
{
switch(opt2)
{
case 1:
system("cls");
cin>>v1;
cout<<"\n Persoa
nele sunt:";
v1.afisare();
cin>>v2;
cout<<"\n Persoa
nele sunt:";
v2.afisare();
getch();
break;
case 2:
system("cls");
/// SE SORTEAZA ELEMENTE
LE MULTIMII v1 SI SE AFISEAZA REZULTATUL ///
v1.sortare();
cout<<"\n\n Per
soanele sortate crescator sunt";
v1.afisare();

/// SE SORTEAZA ELEMENTE

LE MULTIMII v2 SI SE AFISEAZA REZULTATUL ///
v2.sortare();
cout<<"\n\n Per
soanele sortate crescator sunt";
v2.afisare();
getch();
break;
case 3:
system("cls");
/// SE TESTEAZA APARTENE
NTA MULTIMII v1 LA MULTIMEA v2 ///
(v1<v2);
cout<<"\n\n\n\n\
n";
break;
case 4:
system("cls");
/// SE REUNESTE MULTIMEA
v1 CU MULTIMEA v2 ///
cout<<"\nCele do
ua multimi se reunesc !\n";
cout<<"Multimea
devine:\n";
(v1+v2).afisare(
);
getch();
break;
case 5:
system("cls");
/// SE INTERSECTEAZA MULTIME
A v1 CU MULTIMEA v2 ///
cout<<"\nCele do
ua multimi se intersecteaza !\n";
cout<<"Multimea
devine:\n";
(v1*v2).afisare(
);
getch();
break;
case 6:
system("cls");
/// SE FACE DIFERENTA SI
METRICA DINTRE MULTIMEA v1 SI MULTIMEA v2 ///
cout<<"\nSe face
diferenta celor doua multimi !\n";
cout<<"Multimea
devine:\n";
(v1-v2).afisare(
);
getch();
break;
case 7:
system("cls");

/// SE ADAUGA ELEMENTUL

val IN MULTIMEA v1 ///
cout<<"\nDati el
ementul pe care doriti sa-l inserati in prima multime:";
cin>>val1;
(v1+val1);
cout<<"\nMultime
a devine:\n";
v1.afisare();
getch();
break;
case 8:
system("cls");
/// SE EXTRAGE DIN MULTI
MEA v1 ELEMENTUL DE PE POZITIA i ///
cout<<"\nDati po
zitia elementului pe care doriti sa-l stergeti din prima multime:";
cin>>i;
(v1-i);
cout<<"\nMultime
a devine:\n";
v1.afisare();
getch();
break;
case 9:
system("cls");
/// SE VERIFICA APARTENE
NTA ELEMENTULUI val LA MULTIMEA v1 ///
cout<<"\nDati el
ementul pe care doriti sa-l cautati in multime:";
cin>>val1;
(v1*val1);
cout<<"\n\n\n\n\n";
break;
}
system("cls");
submeniu2();
cin>>opt2;
}
break;
}
system("cls");
meniu();
cin>>opt;
}
}