Za virtual
  Vozac(){}
    Vozac(char *ime,int vozrast,int brTrki,bool daliVeteran)
    {
        strcpy(this->ime,ime);
        this->vozrast = vozrast;
        this->brTrki = brTrki;
        this->daliVeteran = daliVeteran;
    }
    virtual float zarabotuvacka() =0;//pure virtual method, makes abstract class

    virtual float danok() = 0;//pure virtual method
.
.
.
    virtual ~Vozac(){}
---------------------------------------------------------------------------------------------------------------------------------------
//primer za override

//1.za vnatre vo f-cija
     //@Override
    float danok()
    {
        if(brTrki>10)
        {
            return zarabotuvacka() * 15/100;
        }
        else
        {
            return zarabotuvacka() * 10 /100;
        }
    }
//2.za nadvor od f-cija
    //@Override
    float getTotalPrice()
    {
        float osnovna = Vozilo::getTotalPrice();

        if(tip==GRATSKI)
            return osnovna;
        else
            return osnovna + 10*osnovna/100;
    }
---------------------------------------------------------------------------------------------------------------------------------------
//nasleduvanje

class Avtobus : public Vozilo
{
private:
    int brPatnici;
    int brGradovi;
public:
    Avtobus () : Vozilo(){}

    Avtobus(char *marka, char *model,int cena,float potrosuvacka,int brPatnici, int brGradovi) : Vozilo(marka, model, cena, potrosuvacka)
    {
        this->brPatnici = brPatnici;
        this->brGradovi = brGradovi;
    }
------------------------------------------------------------------------------------------------------------------------------------
//vidovi copy konstrukotri vo nasleduvanje

   Avtobus(const Vozilo &v,int brVrati, tipAvtomobil tip) : Vozilo(v)//constructor with arguments
    {
        this->brPatnici = brPatnici;
        this->brGradovi = brGradovi;
    }
    Avtobus(const Avtomobil &a): Vozilo(a)//copy constructor
    {
        this->brPatnici = brPatnici;
        this->brGradovi = brGradovi;
    }
---------------------------------------------------------------------------------------------------------------------------------------
//obicehen primer
class MaticenLekar : public Lekar
{
private:
    int brPacienti;
    double *kotizacii;
public:
    MaticenLekar() : Lekar()
    {
        brPacienti=0;
        kotizacii = new double[0];
    }
    MaticenLekar(Lekar &l, int brPacienti,double *kotizacii) : Lekar(l)
    {
        this->brPacienti = brPacienti;
        this->kotizacii = new double[brPacienti];
        for(int i=0;i<brPacienti;i++)
        {
            this->kotizacii[i] = kotizacii[i];
        }
    }
    MaticenLekar(const MaticenLekar &ml) : Lekar(ml)//copy constructor
    {
        this->brPacienti = ml.brPacienti;
        this->kotizacii = new double [brPacienti];
        for(int i=0;i<brPacienti;i++)
        {
            this->kotizacii[i] = ml.kotizacii[i];
        }
    }

    MaticenLekar& operator=(const MaticenLekar &ml)
    {
        if(this!=&ml)
        {
            this->faksimil = ml.faksimil;
            strcpy(this->ime,ml.ime);
            strcpy(this->prezime,ml.prezime);
            this->osnovnaPlata = ml.osnovnaPlata;
            this->brPacienti = ml.brPacienti;
            this->kotizacii = new double[brPacienti];
            for(int i=0;i<brPacienti;i++)
            {
                this->kotizacii[i] = ml.kotizacii[i];
            }
        }
        return *this;
    }
    double prosek()
    {
        double suma=0;
        for(int i=0;i<brPacienti;i++)
        {
            suma+=kotizacii[i];
        }
        return suma/brPacienti;
    }

    //@Override
    void pecati()
    {
        Lekar::pecati();
        cout<<"Prosek na kotizacii: "<<prosek()<<endl;
    }
    double getPlata()
    {
        double osnovna=Lekar::getPlata();
        return osnovna + 30*prosek()/100;
    }
    ~MaticenLekar()
    {
        delete []kotizacii;
    }
};
---------------------------------------------------------------------------------------------------------------------------------------
   //polimorizam i dinamic static
 void najskapKoncert(Koncert **k,int n)
{
    int brElek=0;
    float max=k[0]->cena();
    int index=0;

    for(int i=0;i<n;i++){
        ElektronskiKoncert *ek = dynamic_cast<ElektronskiKoncert*>(k[i]);
        if(ek!=0)
        {
            brElek++;
        }
        if(k[i]->cena() > max)
        {
            max = k[i]->cena();
            index = i;
        }
    }

    cout<<"Najskap koncert: "<<k[index]->getNaziv()<<" "<<k[index]->cena()<<endl;
    cout<<"Elektronski koncerti: "<<brElek<<" od vkupno "<<n<<endl;

}