Objektno polimorfizam

#include<iostream>
using namespace std;
// virtuelni funkcii se tie shto sakame sekoj shto gi nasleduva da gi preoptovari
// obicni virtual imaat default vrednost
// pure virtual =0 nemaat default vrednost i mora da se preoptovarat
/*
class Abstract{
public:
    // pure virtual
    virtual bool daliTone()=0;
    // virtual
    virtual void print(){
    cout<<"Abstract class print"<<endl;
    }
    //
    virtual char tip()=0;

};
class Brod{
protected:
    int kapacitet;
    char *ime;
    float tezina;
public:
    Brod(){
    this->ime=new char[0];
    }
    Brod(char *ime,int kapacitet,float tezina){
    //delete []this->ime;
    this->ime=new char[strlen(ime)+1];
    strcpy(this->ime,ime);
    this->kapacitet=kapacitet;
    this->tezina=tezina;
    }
    ~Brod(){
    delete []ime;
    }
};

class Tanker:public Brod, public Abstract{
private:
    bool legalno;
public:
    Tanker(){}
    Tanker(char *ime,int kapacitet, float tezina, bool legalno):Brod(ime,kapacitet,tezina){
    this->legalno=legalno;
    }
    // preoptovaruvame cisto virtuelna funkcija
    bool daliTone(){
    if(legalno){
        return true;
    }else{
        return false;
    }
    }

    void print(){
    cout<<ime<<" "<<kapacitet<<" "<<tezina<<" "<<legalno<<endl;
    }

    char tip(){
    return 't';
    }
    ~Tanker(){}
};

class Kruzer:public Brod, public Abstract{
private:
    bool bazen;
public:
    Kruzer(){}
    Kruzer(char *ime,int kapacitet, float tezina, bool bazen):Brod(ime,kapacitet,tezina){
    this->bazen=bazen;
    }
    //
    bool daliTone(){
    return false;
    }

    void print(){
    cout<<ime<<" "<<kapacitet<<" "<<tezina<<" "<<bazen<<endl;
    }

    char tip(){
    return 'k';
    }
    ~Kruzer(){}
};

void printBrodovi(Abstract **niza,int n){
for(int i=0;i<n;i++){
    niza[i]->print();
}
}

void kruzerVstanker(Abstract **niza,int n){
int brojKruzeri=0;
int brojTankeri=0;
for(int i=0;i<n;i++){
    Kruzer *pK=dynamic_cast<Kruzer*>(niza[i]);
    if(pK!=0){
        brojKruzeri++;
    }
    Tanker *pT=dynamic_cast<Tanker*>(niza[i]);
    if(pT!=0){
        brojTankeri++;
    }

    if(niza[i]->tip()=='t'){
        brojTankeri++;
    }else{
        brojKruzeri++;
    }
}
cout<<"Kruzer "<<brojKruzeri<<":"<<brojTankeri<<" Tankeri"<<endl;
}
int main(){
Abstract **niza=new Abstract*[2];
niza[0]=new Tanker("Petar",100,70,false);
niza[1]=new Kruzer("David",101,80,true);
kruzerVstanker(niza,2);
return 0;
}
*/



class Zivotno{
protected:
    char boja[15];
    int godini;
public:
    Zivotno(){
    //cout<<"Default constructor zivotno"<<endl;
    }
    Zivotno(char boja[],int godini){
    cout<<"Parameter constructor zivotno"<<endl;
    strcpy(this->boja,boja);
    this->godini=godini;
    }
    // virtuelna funkcija
    virtual void print(){
    cout<<"Zivotno: "<<boja<<" "<<godini<<endl;
    }
    // cisto virtuelna funkcija
    virtual float damage()=0;
    // cisto virtuelna funkcija
    virtual char tip()=0;

    virtual ~Zivotno(){
    cout<<"Default destructor zivotno"<<endl;
    }
};
class Kuce:public Zivotno{
private:
    char rasa[15];
public:
    Kuce(){
    //cout<<"Default constructor Kuce"<<endl;
    }
    Kuce(char boja[],int godini,char rasa[]):Zivotno(boja,godini){
    //cout<<"Parameter constructor Kuce"<<endl;
    //strcpy(this->boja,boja);
    //this->godini=godini;
    strcpy(this->rasa,rasa);
    }
    // override na zivotno funkcijata
    void print(){
    cout<<"Kuce: "<<boja<<" "<<godini<<" "<<rasa<<endl;
    }
    // ako e nad 5 godini, prai 20 damage, ako e nad 1 i pod 5 godini prai 30 damage, ako e pod 1 godina prai 10 damage
    float damage(){
    if(godini>1 && godini<=5){
        return 30;
    }else if(godini>5){
        return 20;
    }else{
        return 10;
    }
    }
    //
    char tip(){
    return 'k';
    }

};

class Mace:public Zivotno{
private:
    bool daliPrede;
public:
    Mace(){
    //cout<<"Default constructor Mace"<<endl;
    }
    Mace(char boja[],int godini,bool daliPrede):Zivotno(boja,godini){
    this->daliPrede=daliPrede;
    }
    // preoptovaruvame virtuelna funkcija
    void print(){
    cout<<"Mace: "<<boja<<" "<<godini<<" "<<daliPrede<<endl;
    }
    // preoptovaruvame cisto virtuelna funkcija
    float damage(){
    if(daliPrede){
        return 1;
    }else{
        return 11;
    }
    }

    char tip(){
    return 'm';
    }
    ~Mace(){
    cout<<"Default destructor Mace"<<endl;
    }
};

void printZivotni(Zivotno **niza,int n){
int flag=1;
for(int i=0;i<n;i++){
    if(niza[i]->damage()<10){
        cout<<"Ne pravat site zivotni nad 10 damage"<<endl;
        flag=0;
        break;
    }
}
if(flag==1){
    cout<<"Site zivotni pravat nad 10 damage"<<endl;
}
}

void najvekjeDamage(Zivotno **niza,int n){
float maxDamage=0;
int pamtiIndex;
for(int i=0;i<n;i++){
    if(niza[i]->damage()>maxDamage){
        maxDamage=niza[i]->damage();
        pamtiIndex=i;
    }
}
cout<<"Najvekje damage pravi zivotnoto:"<<endl;
niza[pamtiIndex]->print();
}

void odnosZivotni(Zivotno **niza,int n){
int brojKucinja=0;
int brojMacinja=0;
Kuce *pK;
Mace *pM;
for(int i=0;i<n;i++){

    pK=dynamic_cast<Kuce*>(niza[i]);
    if(pK!=0){
        brojKucinja++;
    }
    pM=dynamic_cast<Mace*>(niza[i]);
    if(pM!=0){
        brojMacinja++;
    }
    // bez dynamic cast so posebna cisto virtuelna funkcija

    if(niza[i]->tip()=='k'){
        brojKucinja++;
    }else if(niza[i]->tip()=='m'){
        brojMacinja++;
    }

}
cout<<"Kucinja "<<brojKucinja<<":"<<brojMacinja<<" Macinja"<<endl;
}

int main(){
// obicna niza od zivotni
//Zivotno niza[3];
// dinamicki alocirana niza od zivotni
//Zivotno *niza=new Zivotno[3];
// dinamicki alocirana niza od pokazuvaci
Zivotno **niza=new Zivotno*[3];
niza[0]=new Kuce("crno",15,"labrador");
niza[1]=new Kuce("crno-kafeavo",4,"d.o.dz");
niza[2]=new Mace("belo",2,true);

//printZivotni(niza,3);
//najvekjeDamage(niza,3);
//odnosZivotni(niza,3);
delete []niza;
return 0;
}