T11 - zad.2.

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cstring>
#include <new>
#include <stdexcept>

class Tim
{
    char ime[20];
    int broj_odigranih, broj_pobjeda,
        broj_nerijesenih, broj_poraza,
        broj_datih, broj_primljenih, broj_poena;
public:
    Tim(const char ime[]);
    void ObradiUtakmicu(int broj_datih, int broj_primljenih);
    const char *DajImeTima() const { return ime; }
    int DajBrojPoena() const { return broj_poena; }
    int DajGolRazliku() const { return broj_primljenih-broj_datih; }
    void IspisiPodatke() const;
};


class Liga
{
    const int max_br_timova;
    int broj_timova;
    Tim **timovi;
    static bool Kriterij(Tim* tim1, Tim* tim2){
            return tim1->DajBrojPoena()>tim2->DajBrojPoena();}
public:
    explicit Liga(int velicina_lige);
    explicit Liga(std::initializer_list<Tim> lista_timova);
    Liga(const Liga &l);
    Liga(Liga &&l);
    Liga &operator =(const Liga &l);
    Liga &operator =(Liga &&l);
    void DodajNoviTim(const char ime_tima[]);
    void RegistrirajUtakmicu(const char tim1[], const char tim2[],
                             int rezultat_1, int rezultat_2);
    void IspisiTabelu();
};

int main()
{
    try {
    Liga l{5};
    l.DodajNoviTim("Sarajevo");
    l.DodajNoviTim("Zeljeznicar");
    l.DodajNoviTim("Velez");
    l.RegistrirajUtakmicu("Sarajevo","Zeljeznicar",5,0);
    l.RegistrirajUtakmicu("Sarajevo","Velez",5,1);
    l.RegistrirajUtakmicu("Sarajevo","Zeljeznicar",7,0);
    l.RegistrirajUtakmicu("Velez","Zeljeznicar",1,1);
    l.RegistrirajUtakmicu("Sarajevo","Velez",5,0);
    l.RegistrirajUtakmicu("Velez","Zeljeznicar",2,0);
    Liga l2(5);
    l2=std::move(l);
    }
    catch(const char poruka[]) {
        std::cout<<std::endl << poruka << std::endl;
}
    return 0;
}


//IMPLEMENTACIJE ZA KLASU LIGA//

Liga::Liga(int velicina_lige): max_br_timova(velicina_lige),
        broj_timova(0),timovi(new Tim*[velicina_lige]){}

Liga::Liga(std::initializer_list<Tim> lista_timova):
        max_br_timova(lista_timova.size()), broj_timova(lista_timova.size()),
        timovi(new Tim*[lista_timova.size()]){}

//KOPIRAJUCI KONSTRUKTORI:
Liga::Liga(const Liga &l): max_br_timova(l.max_br_timova), broj_timova(l.broj_timova),
            timovi(new Tim*[l.max_br_timova])
     {
        for(int i=0; i<broj_timova; i++) timovi[i]=new Tim(*l.timovi[i]);
        //za svaki pokazivac u nizu dinamicki alociramo klasu tim
        //u koju kopiramo sadrzaj klase tim iz onog cime smo inicijalizirali
     }

Liga::Liga(Liga &&l): max_br_timova(l.max_br_timova), broj_timova(l.broj_timova),
            timovi(l.timovi)
    {
        l.timovi=nullptr; //prijasnji vise ne pokazuje ninasta
        //dok novi pokazuje na niz pokazivaca od ovog prijasnjeg
        l.broj_timova=0;
    }

//OPERATORI DODJELE:
Liga &Liga::operator =(const Liga &l){
    if (l.max_br_timova!=max_br_timova)
        throw std::logic_error("Nejednak maksimalni broj timova");
            //ako imamo A=B, izbrisacemo sadrzaj od A i kopirati u njega sadrzaj od B
                //pod odredjenim uslovima
        if (broj_timova>l.broj_timova){
            for(int i=0; i<l.broj_timova; i++) timovi[i]=l.timovi[i]; //kopirali
                for(int i=l.broj_timova; i<broj_timova; i++)
                    delete timovi[i];} //brisemo ostatak

        if (broj_timova<l.broj_timova){
                for(int i=0; i<broj_timova; i++) timovi[i]=l.timovi[i]; //kopirali
                    for(int i=broj_timova; i<l.broj_timova; i++)
                        timovi[i]=new Tim(*l.timovi[i]);} //alociramo onoliko koliko fali
        broj_timova=l.broj_timova; return *this;
    }

Liga &Liga::operator =(Liga &&l){
        //ako imamo A=std::move(B), izbrisacemo sadrzaj od A,
            //pa cemo sadrzaj od B kopirati u A,
                //zatim sve iz B izbrisati tako da ostane prazan
            if (broj_timova>l.broj_timova){
                for(int i=0; i<l.broj_timova; i++) timovi[i]=l.timovi[i]; //kopirali
                    for(int i=l.broj_timova; i<broj_timova; i++)
                        delete timovi[i];} //brisemo ostatak
            if (broj_timova<l.broj_timova){
                for(int i=0; i<broj_timova; i++) timovi[i]=l.timovi[i]; //kopirali
                    for(int i=broj_timova; i<l.broj_timova; i++)
                        timovi[i]=new Tim(*l.timovi[i]);} //alociramo onoliko koliko fali
    broj_timova=l.broj_timova;
    l.timovi=nullptr; l.broj_timova=0; return *this;
    }

//OSTALE FUNKCIJE
void Liga::DodajNoviTim(const char ime_tima[]){
    if (broj_timova>=max_br_timova) throw "Previse timova!";
    for(int i = 0; i < broj_timova; i++)
    {
        if (std::strcmp(ime_tima, timovi[i]->DajImeTima()) == 0)
          throw "Imena timova se ne smiju ponavljati!";
    }
        timovi[broj_timova++]=new Tim(ime_tima);}

void Liga::RegistrirajUtakmicu(const char tim1[], const char tim2[],
                            int rezultat_1, int rezultat_2){
    Tim* ptim1(nullptr);
        Tim* ptim2(nullptr);
            for(int i = 0; i < broj_timova; i++){
                if (std::strcmp(tim1, timovi[i]->DajImeTima()) == 0) ptim1 = timovi[i];
                if (std::strcmp(tim2, timovi[i]->DajImeTima()) == 0) ptim2 = timovi[i];
                }
            if (ptim1 == 0) throw "Ne postoji tim1!";
            if (ptim2 == 0) throw "Ne postoji tim2!";
        if(ptim1 == ptim2) throw "Imena timova ne smiju biti jednaka!";
    ptim1->ObradiUtakmicu(rezultat_1, rezultat_2);
    ptim2->ObradiUtakmicu(rezultat_2, rezultat_1);
}

void Liga::IspisiTabelu()
{
    std::sort(timovi, timovi+broj_timova, Liga::Kriterij);
    std::cout << std::endl << "Rezultati lige: " << std::endl;
    for(int i = 0; i < broj_timova; i++)
        {timovi[i]->IspisiPodatke();
    std::cout << std::endl;}
}

//IMPLEMENTACIJE ZA KLASU TIM //

Tim::Tim(const char ime[]) : broj_odigranih(0),
      broj_pobjeda(0), broj_nerijesenih(0), broj_poraza(0),
      broj_datih(0), broj_primljenih(0), broj_poena(0)
      { std::strcpy(Tim::ime,ime);}

void Tim::ObradiUtakmicu(int broj_datih, int broj_primljenih)
{
    broj_odigranih++;
    if(broj_datih==broj_primljenih)
        { broj_nerijesenih++; broj_poena+=1; }
    if(broj_datih>broj_primljenih)
        { broj_pobjeda++; broj_poena+=3; }
    if(broj_datih<broj_primljenih)
          broj_poraza++;
    Tim::broj_datih += broj_datih;
    Tim::broj_primljenih += broj_primljenih;
}
void Tim::IspisiPodatke() const
{
    std::cout<<std::left<<std::setw(20)<<ime<<std::right<<
    std::setw(4)<<broj_odigranih<< std::setw(4)<<broj_pobjeda<<
    std::setw(4)<<broj_nerijesenih<< std::setw(4)<<broj_poraza<<
    std::setw(4)<<broj_datih<< std::setw(4)<< broj_primljenih<<
    std::setw(4)<<broj_poena;
}