zadatak sa integralnog a grupa 23.01.2010 radjen na konsultacijama 12.01.2012, vrijeme potrebno cca 180 minuta

integralni_210110a

#include <iostream>
#include <vector>
#include <exception>

using namespace std;

const char * ln = "---------------------------------------------\n";

// kolekcija gotova
template <class T1, class T2>
class Kolekcija
{
    T1 _clan1[20];
    T2 _clan2[20];
    int _trenutnoClanova;
protected:
    void init(int trenutnoClanova = 0, T1 clan1[] = NULL, T2 clan2[] = NULL)
    {
        _trenutnoClanova = trenutnoClanova;
        for(int i = 0; i < trenutnoClanova; i++) {
            _clan1[i] = clan1[i];
            _clan2[i] = clan2[i];
        }
    }
public:
    Kolekcija()
    {
        init();
    }
    Kolekcija(Kolekcija & original)
    {
        init(original._trenutnoClanova, original._clan1, original._clan2);
    }
    Kolekcija & operator=(Kolekcija & original)
    {
        init(original._trenutnoClanova, original._clan1, original._clan2);
    }
    void addElement(T1 element1, T2 element2)
    {
        if(_trenutnoClanova < 20) {
            _clan1[_trenutnoClanova] = element1;
            _clan2[_trenutnoClanova] = element2;
            _trenutnoClanova++;
        } else {
            throw new exception;
        }
    }
    void removeElement(int index)
    {
        if(index < _trenutnoClanova) {
            for(int i = index; i < index; i++) {
                *(_clan1[i]) = *(_clan1[i + 1]);
                _clan2[i] = _clan2[i + 1];
            }
            _trenutnoClanova--;
        } else {
            throw new exception;
        }
    }
    Kolekcija & operator+=(Kolekcija & original)
    {
        if(_trenutnoClanova + original._trenutnoClanova <= 20) {
            for(int i = 0; i < original._trenutnoClanova; i++) {
                addElement(original._clan1[i], original._clan2[i]);
            }
        } else {
            throw new exception;
        }
        return this;
    }
    friend ostream & operator<<(ostream & out, Kolekcija<T1, T2> & original)
    {
        for(int i = 0; i < original._trenutnoClanova; i++) {
            out << *(original._clan1[i]) << ' ' << original._clan2[i] << endl;
        }
        return out;
    }
};

// Osoba gotova
class Osoba
{
protected:
    void init(const char * imePrezime)
    {
        _imePrezime = new char[strlen(imePrezime) + 1];
        strcpy(_imePrezime, imePrezime);
    }
    void deinit()
    {
        delete _imePrezime;
        _imePrezime = NULL;
    }
    char * _imePrezime;
public:
    Osoba(const char * imePrezime)
    {
        init(imePrezime);
    }
    virtual ~Osoba()
    {
        deinit();
    }
    virtual void info() = 0;
    Osoba(Osoba & original)
    {
        init(original._imePrezime);
    }
    Osoba & operator=(Osoba & desni)
    {
        init(desni._imePrezime);
    }
};

// predmet gotov
class Predmet
{
    char * _naziv;
    char * _profesor;
protected:
    void init(const char * naziv, const char * profesor)
    {
        strcpy(_naziv, naziv);
        strcpy(_profesor, profesor);
    }
    void deinit()
    {
        delete _naziv;
        delete _profesor;
        _naziv = NULL;
        _profesor = NULL;
    }
public:
    Predmet(const char * naziv = "Nema naziva", const char * profesor = "Nema profesora")
    {
        _naziv = new char[strlen(naziv)  + 1];
        _profesor = new char[strlen(profesor)  + 1];
        init(naziv, profesor);
    }
    virtual ~Predmet()
    {
        deinit();
    }
    Predmet(Predmet & original)
    {
        _naziv = new char[strlen(original._naziv)  + 1];
        _profesor = new char[strlen(original._profesor)  + 1];
        init(original._naziv, original._profesor);
    }
    Predmet & operator=(Predmet & original)
    {
        init(original._naziv, original._profesor);
    }
    friend ostream & operator<<(ostream & out, Predmet & original)
    {
        out << "Predmet: " << original._naziv << " Profesor: " << original._profesor << ":";
        return out;
    }
};

class Student : public Osoba
{
    const int _brojIndeksa;
    Kolekcija<Predmet *, int> _polozeni;
    vector<string> _seminarski;
protected:
    void init(Kolekcija<Predmet *, int> & polozeni, vector<string> & seminarski)
    {
        _polozeni = polozeni;
        _seminarski = seminarski;
    }
    int pronadjiSeminarski(const char * naziv)
    {
        int velicina = _seminarski.size();
        for(int i = 0; i < velicina; i++) {
            if(_seminarski[i].compare(naziv) == 0) {
                return i;
            }
        }
        return -1;
    }
    bool postojiSeminarski(const char * naziv)
    {
        if(pronadjiSeminarski(naziv) >= 0) {
            return true;
        } else {
            return false;
        }
    }
public:
    Student(const char * imePrezime = "Nema Imena", int brojIndeksa = 0)
        : _brojIndeksa(brojIndeksa), Osoba(imePrezime)
    {
    }
    Student(Student & original)
        : _brojIndeksa(original._brojIndeksa), Osoba(original._imePrezime)
    {
        init(original._polozeni, original._seminarski);
    }
    Student & operator=(Student & original)
    {
        _imePrezime = original._imePrezime;
        init(original._polozeni, original._seminarski);
    }
    void info()
    {
        cout << ln << "Ja sam student i zovem se " << _imePrezime << endl;
    }
    void dodajPolozeniPredmet(const char * predmet, const char * profesor, int ocjena)
    {
        Predmet * temp = new Predmet(predmet, profesor);
        _polozeni.addElement(temp, ocjena);
    }
    bool dodajSeminarski(const char * naziv)
    {
        if(!postojiSeminarski(naziv)) {
            _seminarski.push_back(naziv);
            return true;
        }
        return false;
    }
    bool ukloniSeminarski(const char * naziv)
    {
        int pozicija = pronadjiSeminarski(naziv);
        if(pozicija >= 0) {
            _seminarski.erase(_seminarski.begin() + pozicija);
            return true;
        } else {
            return false;
        }
    }
    friend ostream & operator<<(ostream & out, Student & original)
    {
        out << "Index: " << original._brojIndeksa << endl
            << original._polozeni;
        int velicina = original._seminarski.size();
        for(int i = 0; i < velicina; i++) {
            out << "Seminarski rad " << i + 1 << ": " << original._seminarski[i] << endl ;
        }
        return out;
    }
};

int main()
{
    Student * stud1 = new Student("Ibrahim Jukan", 2949);
    Student * stud2 = new Student("Hamo Hapic", 746);

    stud1->dodajPolozeniPredmet("PR2", "Bjarne Stroustrup", 10);
    stud1->dodajPolozeniPredmet("AI", "Peter Norvig", 10);
    stud1->dodajPolozeniPredmet("ML", "Andrew Ng", 10);
    stud2->dodajPolozeniPredmet("UOS", "Andrew Tanenbaum", 10);
    stud2->dodajPolozeniPredmet("UBP", "Edgar Codd", 10);
    stud2->dodajSeminarski("Projektna dokumentacija");

    stud1->info();
    cout << *stud1;
    stud2->info();
    cout << *stud2;

    Student stud3 = *stud1;

    *stud1 = *stud2;
    stud1->info();
    cout << *stud1;

    stud3.info();
    cout << stud3;

    Osoba * insan;

    // Upcasting + polimorfizam = mogucnost implementiranja razlicitog ponasanja za razlicite izvedene klase iste bazne klase, izvedene klase dijele sve ostalo osim polimorfnih klasa, koje su njima jednistvene i implementirane su mehanizmom kasnog povezivanja, tj. one se ne povezuju u vremenu prevodjenja, vec u vremenu izvrsavanja koda
    insan = stud2;
    insan->info();
    insan = &stud3;
    insan->info();

    return 0;
}