[Zadatak] Genericka klasa Skupne znam sta da radim
sto sam znao radio sam stvarno ne znam do cega bi vise moglo biti
tek ucim ove klase pa sam i ovako zbunjen :):(
nemojte se samo uplasiti duzine koda puno ima neibrisanih komentara pa je malo ispao predugacak kod
hvala unaprijed
--zadatak glasi:
U raznim oblastima matematike često se javlja potreba za radom sa skupovima. Vaš zadatak je
da razvijete generičku klasu “Skup” koja predstavlja skup čiji elementi mogu biti proizvoljnog,
ali istog tipa (odnosno svi elementi skupa moraju biti istog tipa, tako da skupovi heterogenog
sastava nisu podržani), za koje ćemo pretpostaviti da je definiran poredak pomoću operatora “<”.
Klasa treba da ima sljedeće elemente:
a) Privatne atribute koji redom predstavljaju broj elemenata u skupu, kapacitet skupa (tj.
maksimalni broj elemenata koji se mogu smjestiti u skup) i pokazivač na dinamički
alocirani niz (preciznije, na njegov prvi element) koji će čuvati elemente skupa;
3
b) Konstruktor sa jednim parametrom, koji predstavlja kapacitet skupa, i koji vrši
dinamičku alokaciju prostora za čuvanje elemenata skupa. Inicijalni broj elemenata
kreiranog skupa je 0 (prazan skup). Pri tome je potrebno zabraniti da se ovaj konstruktor
koristi za automatsku konverziju cjelobrojnog tipa u tip “Skup”;
c) Destruktor, koji oslobadja memoriju zauzetu konstruktorom;
d) Konstruktor kopije koji ce osigurati da se objekti tipa “Skup” mogu bezbjedno prenositi
kao parametri po vrijednosti i vraćati kao rezultati iz funkcija;
e) Preklopljeni operator dodjele, koji garantira sigurno dodjeljivanje jednog skupa drugom
skupu, bez problema koji mogu biti uzrokovani kreiranjem plitkih kopija;
f) Metodu sa jednim parametrom, koja dodaje u skup element predstavljen parametrom. U
slučaju da se takav element već nalazi u skupu, unos elementa treba ignorirati (ne
zaboravimo da skupovi po matematskoj definiciji ne mogu sadržavati jednake
elemente). U slucaju da je dostignut kapacitet skupa, metoda treba da baci izuzetak;
g) Metodu bez parametara, koja vraća kao rezultat broj elemenata skupa;
h) Metodu sa jednim parametrom, koja vraća kao rezultat “true” ukoliko se element
predstavljen parametrom nalazi u skupu, a “false” ukoliko se ne nalazi;
i) Preklopljen unarni operator “!”, koji primijenjen na skup daje “true” ukoliko je skup
prazan, a “false” ukoliko nije;
j) Preklopljen operator “<<” koji treba da podrži ispis skupova na ekran. Skupovi se
ispisuju kao slijed svojih elemenata unutar vitičastih zagrada, međusobno razdvojenih
zarezima. Pri ispisu, elementi treba da budu sortirani u rastući poredak (redoslijed
elemenata je kod skupova svakako nebitan). Za sortiranje možete koristiti funkiju
“sort” (bez funkcije kriterija, jer je pretpostavljeno da su elementi skupa takvi da je za
njih definiran poredak uz pomoć operatora “<”);
k) Preklopljene binarne operatore “+”, “*” i “-” koji redom nalaze uniju, presjek i razliku
skupova koji su navedeni kao operandi. Uputa: Ranije napisane metode za dodavanje
novog elementa u skup i ispitivanje da li element pripada skupu mogu Vam biti od
velike koristi pri pisanju operatorskih funkcija za ove operatore. Dalje, kapacitet skupa
koji ćete vratiti kao rezultat unije “A + B” možete definirati kao zbir broja elemenata
skupova “A” i “B”, bez obzira sto će broj elemenata unije “A + B” možda biti manji,
ukoliko skupovi “A” i “B” sadrže zajedničke elemente (ionako će prilikom dodjele tipa
“C = A + B” rezultat biti kopiran u skup “C”, a pri ispisu tipa “cout << A + B” zbir
“A + B” se svakako tretira kao privremeni objekat). Slično, za kapacitet presjeka
“A * B” i razlike “A - B” možete uzeti broj elemenata skupa “A”, jer “A * B” i “A – B”
svakako ne mogu imati više elemenata nego što ima skup “A”;
l) Prekopljene binarne operatore “+=”,“*=” i “–=” pri cemu izrazi “A += B”, “A *= B” i
“A –= B” predstavljaju respektivno skraćene zapise za izraze “A = A + B”, “A = A * B”
i “A = A – B”;
m) Preklopljene binarne relacione operatore “<=”,“>=”,“==”,“!=”,“<” i “>” pri čemu
relacije “A <= B”, “A >= B”, “A == B”, “A != B”, “A < B” i “A > B” predstavljaju
respektivno odnose “A je podskup od B”, “A je nadskup od B”, “A i B su jednaki”, “A i B
su različiti”, “A je pravi podskup od B”, “A je pravi nadskup od B”. Uputa: Prvo
definirajte operator “<=”. Dalje, vrijedi “A >= B” ako je “B <= A”. Vrijedi “A == B” ako
je “A >= B” i “A <= B”. Vrijedi “A != B” ako nije “A == B”. Vrijedi “A < B” ako je
“A <= B” i “A != B”. Vrijedi “A > B” ako je “A >= B” i “A != B”. Dakle, sve relacione
operatore možete definirati polazeći samo od operatora “<=”.
Sve metode implementirajte izvan deklaracije klase, osim trivijalnih metoda koje trebate
implementirati direktno unutar deklaracije klase. Obavezno napišite i testni program u kojem
ćete demonstrirati sve elemente napisane generičke klase uzimajući stringove (tj. objekte tipa
“string”) za elemente skupova.
Code:
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
template<typename Tip>
class Skup{
/*a*/ int br_el;
int kapacitet;
Tip *elementi;
public:
/*b*/ explicit Skup(int kap):kapacitet(kap),br_el(0),elementi(new Tip[kap]){}
/*c*/ ~Skup(){delete[] elementi;}
/*d*/ Skup(const Skup &s);
/*e*/ Skup &operator=(const Skup &s);
/*f*/ void Dodaj(Tip element);
/*g*/ int VratiBrojElemenata() {return br_el;}
/*h*/ bool Pripada(int element);
/*i*/ template<typename Tip1>
friend bool operator!(const Skup &s);
/*j*/template<typename Tip1>
friend ostream &operator <<(ostream &cout,const Skup &s);
/*k*/template<typename Tip1>
friend Skup<Tip1> operator+(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend Skup<Tip1> operator *(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend Skup<Tip1> operator -(const Skup &s1,const Skup &s2);
/*l*/ template<typename Tip1>
//Skup<Tip1> &operator +=(const Skup &s) {return *this=*this+s;}
friend Skup &operator +=(Skup &s1,const Skup &s2) {return s1=s1+s2;}
template<typename Tip1>
friend Skup &operator -=(Skup &s1,const Skup &s2) {return s1=s1-s2;}
friend Skup &operator *=(Skup &s1,const Skup &s2) {return s1=s1*s2; }
/*m*/ template<typename Tip1>
friend bool operator <=(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator >=(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator ==(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator !=(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator <(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator >(const Skup &s1,const Skup &s2);
//pomocne funkcije:
double Element(int i)const{
if(i<1||i>br_el)throw"Pogresan indeks!\n";return elementi[i-1];}
double &Element(int i){
if(i<1||i>br_el)throw"Pogresan indeks!\n";return elementi[i-1];}
};
//*********************************************************
/*template <typename Tip>
Skup<Tip>::Skup(int kap){
kapacitet=kap;
br_el=0;
elementi=new int[kapacitet];
}*/
//*****************************************
template<typename Tip>
Skup<Tip>::Skup(const Skup &s){
br_el=s.br_el;
kapacitet=s.kapacitet;
elementi=new Tip[s.kapacitet];
for(int i=0;i<kapacitet;i++) elementi[i]=s.elementi[i];
}
//************************************
template<typename Tip>
Skup<Tip> &Skup<Tip>::operator=(const Skup &s){
/*if(Kapacitet<s.Kapacitet){
delete[] Elementi;
Elementi=new int [s.Kapacitet];
}*/
if(&s == this)return *this;
delete[] elementi;
elementi=new Tip[s.kapacitet];
br_el=s.br_el;
kapacitet=s.kapacitet;
for(int i=0;i<kapacitet;i++) elementi[i]=s.elementi[i];
return *this;
}
//*********************************
template<typename Tip>
void Skup<Tip>::Dodaj(Tip element)
{
/*if(br_el==kapacitet) throw "Kapacitet je popunjen!";
else{
int TuJe=0;
for(int i=0;i<BrojElemenata;i++)
if(Elementi[i]==element) TuJe=1;
if(!TuJe) Elementi[BrojElemenata++]=element;
}*/
if(br_el==kapacitet)throw"Nemoze stati vise elemenata!\n";
for(int i(0);i<br_el;i++)
{
if(elementi[i]==element)return;
}
elementi[br_el]=element;
br_el++;
}
//*************************************
template<typename Tip>
bool Skup<Tip>::Pripada(int element){
/*int TuJe=0;
for(int i=0;i<BrojElemenata;i++)
if(Elementi[i]==element) TuJe=1;
if(TuJe) return true;
else if(!TuJe) return false;
*/
for(int i(0);i<br_el;i++)
{
if(elementi[i]==element)return true;
}
return false;
}
//**********************************
template<typename Tip>
bool operator!(const Skup<Tip> &s)
{
if(s.br_el==0) return true;
else return false;
}
//**************************************
template <typename Tip>
Skup<Tip>operator+(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
Skup<Tip> s3(s1.br_el+s2.br_el);
for(int i=0;i<s1.br_el;i++) s3.Dodaj(s1.elementi[i]);
for(int i=0;i<s2.br_el;i++) s3.Dodaj(s2.elementi[i]);
return s3;
}
//
template <typename Tip>
Skup<Tip>operator -(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
Skup<Tip> s3(s1.br_el);
for(int i(0);i<s1.br_el;i++)
{
if(s1.Pripada(s1.elementi[i]) && !s2.Pripada(s1.elementi[i]))
s3.Dodaj(s1.elementi[i]);
}
return s3;
}
//
template <typename Tip>
Skup<Tip>operator *(const Skup<Tip> &s1,const Skup<Tip> &s2){
Skup<Tip> s3(s1.kapacitet);
for(int i(0);i<s1.br_el;i++)
{
if(s1.Pripada(s1.elementi[i]) && s2.Pripada(s1.elementi[i]))
s3.Dodaj(s1.elementi[i]);
}
return s3;
}
//
/*template <typename Tip>
bool kriterij(const void *a,const void *b){
int *a1=(int *)a;
int *b1=(int *)b;
if(*a1>*b1) return 1;
else if(*a1<*b1) return -1;
else return 0;
}*/
//
template <typename Tip>
ostream &operator <<(ostream &cout,const Skup<Tip> &s)
{
sort(s.elementi,s.elementi+s.br_el);
/*cout<<"{";
for(int i=0;i<s.br_el;i++){
if(i+1<s.Bbr_el) cout<<s.elementi[i]<<",";
else if(i+1==s.br_el) cout<<s.elementi[i]<<"}";
}
return cout;
*/
cout<<"{";
for(int i(0);i<s.br_el-1;i++)
{
cout<<s.elementi[i]<<",";
}
return cout<<elementi[s.br_el-1]<<"}";
}
//**********************************
template <typename Tip>
bool operator <=(const Skup<Tip> &s1,const Skup<Tip> &s2){
for(int i=0;i<s1.br_el;i++)
if(!(s2.Pripada(s1.elementi[i]))) return false;
return false;
}
//
template <typename Tip>
bool operator >=(const Skup<Tip> &s1,const Skup<Tip> &s2){
if(s2<=s1) return true;
else return false;
}
//
template <typename Tip>
bool operator ==(const Skup<Tip> &s1,const Skup<Tip> &s2){
if(s1>=s2&&s1<=s2) return 1;
else return 0;
}
template <typename Tip>
bool operator!=(const Skup<Tip> &s1,const Skup<Tip> &s2){
if(!(s1==s2)) return 1;
else return 0;
}
template <typename Tip>
bool operator <(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
if((s1<=s2)&&(s1!=s2))return true;
else return false;
}
template<typename Tip>
bool operator >(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
if((s1>=s2)&&(s1!=s2))return true;
else return false;
}
int main()
{
try
{
Skup<double> a(4);
Skup<double> b(3);
b.Dodaj(9);
b.Dodaj(7);
a.Dodaj(1);
a.Dodaj(3);
a.Dodaj(2);
cout<<a+=b<<endl;
Skup<double> c=a*b;
cout<<c<<endl;
cout<<a-=b<<endl;
}
catch(const char tekst[]){
cout<<tekst;
}
system("pause");
return 0;
}
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
template<typename Tip>
class Skup{
/*a*/ int br_el;
int kapacitet;
Tip *elementi;
public:
/*b*/ explicit Skup(int kap):kapacitet(kap),br_el(0),elementi(new Tip[kap]){}
/*c*/ ~Skup(){delete[] elementi;}
/*d*/ Skup(const Skup &s);
/*e*/ Skup &operator=(const Skup &s);
/*f*/ void Dodaj(Tip element);
/*g*/ int VratiBrojElemenata() {return br_el;}
/*h*/ bool Pripada(int element);
/*i*/ template<typename Tip1>
friend bool operator!(const Skup &s);
/*j*/template<typename Tip1>
friend ostream &operator <<(ostream &cout,const Skup &s);
/*k*/template<typename Tip1>
friend Skup<Tip1> operator+(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend Skup<Tip1> operator *(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend Skup<Tip1> operator -(const Skup &s1,const Skup &s2);
/*l*/ template<typename Tip1>
//Skup<Tip1> &operator +=(const Skup &s) {return *this=*this+s;}
friend Skup &operator +=(Skup &s1,const Skup &s2) {return s1=s1+s2;}
template<typename Tip1>
friend Skup &operator -=(Skup &s1,const Skup &s2) {return s1=s1-s2;}
friend Skup &operator *=(Skup &s1,const Skup &s2) {return s1=s1*s2; }
/*m*/ template<typename Tip1>
friend bool operator <=(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator >=(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator ==(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator !=(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator <(const Skup &s1,const Skup &s2);
template<typename Tip1>
friend bool operator >(const Skup &s1,const Skup &s2);
//pomocne funkcije:
double Element(int i)const{
if(i<1||i>br_el)throw"Pogresan indeks!\n";return elementi[i-1];}
double &Element(int i){
if(i<1||i>br_el)throw"Pogresan indeks!\n";return elementi[i-1];}
};
//*********************************************************
/*template <typename Tip>
Skup<Tip>::Skup(int kap){
kapacitet=kap;
br_el=0;
elementi=new int[kapacitet];
}*/
//*****************************************
template<typename Tip>
Skup<Tip>::Skup(const Skup &s){
br_el=s.br_el;
kapacitet=s.kapacitet;
elementi=new Tip[s.kapacitet];
for(int i=0;i<kapacitet;i++) elementi[i]=s.elementi[i];
}
//************************************
template<typename Tip>
Skup<Tip> &Skup<Tip>::operator=(const Skup &s){
/*if(Kapacitet<s.Kapacitet){
delete[] Elementi;
Elementi=new int [s.Kapacitet];
}*/
if(&s == this)return *this;
delete[] elementi;
elementi=new Tip[s.kapacitet];
br_el=s.br_el;
kapacitet=s.kapacitet;
for(int i=0;i<kapacitet;i++) elementi[i]=s.elementi[i];
return *this;
}
//*********************************
template<typename Tip>
void Skup<Tip>::Dodaj(Tip element)
{
/*if(br_el==kapacitet) throw "Kapacitet je popunjen!";
else{
int TuJe=0;
for(int i=0;i<BrojElemenata;i++)
if(Elementi[i]==element) TuJe=1;
if(!TuJe) Elementi[BrojElemenata++]=element;
}*/
if(br_el==kapacitet)throw"Nemoze stati vise elemenata!\n";
for(int i(0);i<br_el;i++)
{
if(elementi[i]==element)return;
}
elementi[br_el]=element;
br_el++;
}
//*************************************
template<typename Tip>
bool Skup<Tip>::Pripada(int element){
/*int TuJe=0;
for(int i=0;i<BrojElemenata;i++)
if(Elementi[i]==element) TuJe=1;
if(TuJe) return true;
else if(!TuJe) return false;
*/
for(int i(0);i<br_el;i++)
{
if(elementi[i]==element)return true;
}
return false;
}
//**********************************
template<typename Tip>
bool operator!(const Skup<Tip> &s)
{
if(s.br_el==0) return true;
else return false;
}
//**************************************
template <typename Tip>
Skup<Tip>operator+(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
Skup<Tip> s3(s1.br_el+s2.br_el);
for(int i=0;i<s1.br_el;i++) s3.Dodaj(s1.elementi[i]);
for(int i=0;i<s2.br_el;i++) s3.Dodaj(s2.elementi[i]);
return s3;
}
//
template <typename Tip>
Skup<Tip>operator -(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
Skup<Tip> s3(s1.br_el);
for(int i(0);i<s1.br_el;i++)
{
if(s1.Pripada(s1.elementi[i]) && !s2.Pripada(s1.elementi[i]))
s3.Dodaj(s1.elementi[i]);
}
return s3;
}
//
template <typename Tip>
Skup<Tip>operator *(const Skup<Tip> &s1,const Skup<Tip> &s2){
Skup<Tip> s3(s1.kapacitet);
for(int i(0);i<s1.br_el;i++)
{
if(s1.Pripada(s1.elementi[i]) && s2.Pripada(s1.elementi[i]))
s3.Dodaj(s1.elementi[i]);
}
return s3;
}
//
/*template <typename Tip>
bool kriterij(const void *a,const void *b){
int *a1=(int *)a;
int *b1=(int *)b;
if(*a1>*b1) return 1;
else if(*a1<*b1) return -1;
else return 0;
}*/
//
template <typename Tip>
ostream &operator <<(ostream &cout,const Skup<Tip> &s)
{
sort(s.elementi,s.elementi+s.br_el);
/*cout<<"{";
for(int i=0;i<s.br_el;i++){
if(i+1<s.Bbr_el) cout<<s.elementi[i]<<",";
else if(i+1==s.br_el) cout<<s.elementi[i]<<"}";
}
return cout;
*/
cout<<"{";
for(int i(0);i<s.br_el-1;i++)
{
cout<<s.elementi[i]<<",";
}
return cout<<elementi[s.br_el-1]<<"}";
}
//**********************************
template <typename Tip>
bool operator <=(const Skup<Tip> &s1,const Skup<Tip> &s2){
for(int i=0;i<s1.br_el;i++)
if(!(s2.Pripada(s1.elementi[i]))) return false;
return false;
}
//
template <typename Tip>
bool operator >=(const Skup<Tip> &s1,const Skup<Tip> &s2){
if(s2<=s1) return true;
else return false;
}
//
template <typename Tip>
bool operator ==(const Skup<Tip> &s1,const Skup<Tip> &s2){
if(s1>=s2&&s1<=s2) return 1;
else return 0;
}
template <typename Tip>
bool operator!=(const Skup<Tip> &s1,const Skup<Tip> &s2){
if(!(s1==s2)) return 1;
else return 0;
}
template <typename Tip>
bool operator <(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
if((s1<=s2)&&(s1!=s2))return true;
else return false;
}
template<typename Tip>
bool operator >(const Skup<Tip> &s1,const Skup<Tip> &s2)
{
if((s1>=s2)&&(s1!=s2))return true;
else return false;
}
int main()
{
try
{
Skup<double> a(4);
Skup<double> b(3);
b.Dodaj(9);
b.Dodaj(7);
a.Dodaj(1);
a.Dodaj(3);
a.Dodaj(2);
cout<<a+=b<<endl;
Skup<double> c=a*b;
cout<<c<<endl;
cout<<a-=b<<endl;
}
catch(const char tekst[]){
cout<<tekst;
}
system("pause");
return 0;
}
