Navigacija
Lista poslednjih: 16, 32, 64, 128 poruka.

[Zadatak] Genericka klasa Skup

[es] :: C/C++ programiranje :: C/C++ za početnike :: [Zadatak] Genericka klasa Skup

[ Pregleda: 2175 | Odgovora: 5 ] > FB > Twit

Postavi temu Odgovori

Autor

Pretraga teme: Traži
Markiranje Štampanje RSS

chalka
chalka chalka
BiH

Član broj: 74148
Poruke: 16
*.dlp215.bih.net.ba.



Profil

icon [Zadatak] Genericka klasa Skup06.06.2006. u 00:04 - pre 195 meseci
molim vas da mi kazte u cemu ja fazon u ovom programu zasto neradi
ne 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;
}
 
Odgovor na temu

chalka
chalka chalka
BiH

Član broj: 74148
Poruke: 16
*.dlp215.bih.net.ba.



Profil

icon Re: [Zadatak] Genericka klasa Skup06.06.2006. u 00:06 - pre 195 meseci
molim kolege sa faksa da ne zloupotrebljavaju kod namucio sam se pravo dok sam uradio ovo malo jada
chalka
 
Odgovor na temu

Mali Misha
Mihajlo Anđelković
NBGD

Član broj: 79396
Poruke: 379
*.powernet.bg.

ICQ: 195487525
Sajt: cpptea.com


+1 Profil

icon Re: [Zadatak] Genericka klasa Skup06.06.2006. u 11:19 - pre 195 meseci
Koliko sam razumeo radi se o elementima istog tipa. Znači ne bi trebalo da ima potrebe za Tip i Tip1. Potom, verovatno nije eksplicitno traženo da napraviš gomilu eksternih friend operatora. Definiši ih slobodno unutar klase.

Code:
template <typename T>
class Skup {

    int x;

    public:
        Skup<T>& operator+(const Skup<T>&s) const
        {
            // ...

            x;        // x od prvog sabirka
            this->x;  // x od provog sabirka
            s.x;      // x od drugog sabirka

            // ...
        }
};


Prvi sabirak je ovde u stvari lokalni objekat jer je preko njega metoda i pozvana. Njegovim elementima se pristupa preko this-> ili bez ikakvih specifikacija, ako nema višeznačnosti. Drugi sabirak je objekat Skup dobijen preko argumenta.

Reč const iza zatvorene zagrade se obično dodaje kod metoda koje nisu predviđene da menjaju objekat za koga su pozvane poput operator+, operator-, operator== itd. Suprotno važi za operator+=, operator-= itd. Reč const ispred argumenta s označava da se on ne sme menjati u metodi.

Za početak bi možda bilo najbolje da uopšte ne koristiš const jer se nestrpljenjem lako dolazi do niza grešaka ali sam proceni. Verovatno će se većina stvari srediti same od sebe kada implementiraš operatore unutar klase.
Ipak se ++uje.
 
Odgovor na temu

tupito
Vladan Milivojevic
Beograd

Član broj: 55195
Poruke: 54
*.041net.co.yu.



Profil

icon Re: [Zadatak] Genericka klasa Skup06.06.2006. u 14:01 - pre 195 meseci
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)const;
    /*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<Tip1> &operator +=(Skup<Tip1> &s1,const Skup<Tip1> &s2) {return s1=s1+s2;}
    template<typename Tip1>
    friend Skup<Tip1> &operator -=(Skup<Tip1> &s1,const Skup<Tip1> &s2) {return s1=s1-s2;}
    template<typename Tip1>
    friend Skup<Tip1> &operator *=(Skup<Tip1> &s1,const Skup<Tip1> &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)const{
    /*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<<s.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=" << a << '\n';
        cout<< "B=" << b << '\n';
        cout<< "A+=B=" <<(a+=b)<<endl;
        Skup<double> c=a*b; 
        cout<< "C=A*B="<<c<<endl; 
        cout<< "A-=B="<<(a-=b)<<endl;

    }
    catch(const char tekst[]){
        cout<<tekst;
    } 

    system("pause"); 
    return 0;
}



sad bi trebao da radi
 
Odgovor na temu

chalka
chalka chalka
BiH

Član broj: 74148
Poruke: 16
*.dlp378.bih.net.ba.



Profil

icon Re: [Zadatak] Genericka klasa Skup06.06.2006. u 15:50 - pre 195 meseci
prvo da vam se zahvalim sto ste se uopste
odvojili vremena da bi mi pomogli
probao sam ovaj drugi code neradi opet javlja iste greske (koristim Dev-c++)
a "nesmijemo" implementirati funkcije unutar klase(tako je zadano u zazatku)
jedino neke kratke sa kodom u dva reda
 
Odgovor na temu

Mali Misha
Mihajlo Anđelković
NBGD

Član broj: 79396
Poruke: 379
*.powernet.bg.

ICQ: 195487525
Sajt: cpptea.com


+1 Profil

icon Re: [Zadatak] Genericka klasa Skup06.06.2006. u 16:21 - pre 195 meseci
Pa dobro, implementiraj metode izvan klase ali ih deklariši unutra. Mislim da je to ono što se očekuje od rešenja zadatka. Kod ispod je samo primer kako ove implementacija izgleda, ne i deo programa koji ti trebaš da napišeš.

Code:
template <typename T>
class Skup {

    int x;

    public:
        Skup<T> operator+(const Skup<T>&s) const;
};

template<typename T>
Skup<T> Skup<T>::operator+(const Skup<T>&s) const
{
    // ...

    x;        // x od prvog sabirka
    this->x;  // x od provog sabirka
    s.x;      // x od drugog sabirka

    // ...

    return Skup<T>;
}

Ipak se ++uje.
 
Odgovor na temu

[es] :: C/C++ programiranje :: C/C++ za početnike :: [Zadatak] Genericka klasa Skup

[ Pregleda: 2175 | Odgovora: 5 ] > FB > Twit

Postavi temu Odgovori

Navigacija
Lista poslednjih: 16, 32, 64, 128 poruka.