Objektno polimorfizam gr1

#include<iostream>
using namespace std;
// abstract class - klasa shto ima samo virtuelni metodi
class Abstract{
public:

    virtual void jumpAttack()=0;
    virtual void basicAttack(){
    cout<<"class Attack"<<endl;
    }
};

class Enemy{
protected:
    int health;
    int movement;
public:
    Enemy(){}
    Enemy(int health,int movement){
    this->health=health;
    this->movement=movement;
    }

    virtual ~Enemy(){
    cout<<"Enemy destructor"<<endl;
    }
};

class Kursum: public Enemy, public Abstract{
private:
    char kalibar[5];
public:
    Kursum(){}
    Kursum(int health,int movement,char kalibar[]):Enemy(health,movement){
    strcpy(this->kalibar,kalibar);
    }
    void jumpAttack(){
    cout<<"Kursum jump attack"<<endl;
    }
    ~Kursum(){
    cout<<"Kursum destructor"<<endl;
    }
};
class Pecurka: public Enemy, public Abstract{
private:
    char boja[15];
public:
    Pecurka(){}
    Pecurka(int health,int movement,char boja[]):Enemy(health,movement){
    strcpy(this->boja,boja);
    }
    void jumpAttack(){
    cout<<"Pecurka jump attack"<<endl;
    }
    ~Pecurka(){
    cout<<"Pecurka destructor"<<endl;
    }
};

void funkcija(Abstract **niza,int n){
for(int i=0;i<n;i++){
    niza[i]->jumpAttack();
}
}
int main(){
Abstract **niza=new Abstract*[2];
niza[0] = new Pecurka(100,2,"crvena");
niza[1] = new Kursum(250,1,"crn");
delete []niza;
funkcija(niza,2);
return 0;
}

// virtual - moze i ne mora da se preoptovari | proveruva prvo dali e preoptovarena funkcijata
// pure virtual - mora da se preoptovari
class Zivotno{
protected:
    char boja[15];
    float tezina;
public:
    Zivotno(){
    //cout<<"Default constructor Zivotno"<<endl;
    }
    Zivotno(char boja[],float tezina){
    //cout<<"Parameter constructor Zivotno"<<endl;
    strcpy(this->boja,boja);
    this->tezina=tezina;
    }
    // obicna virtuelna funkcija
    virtual void print(){
    cout<<"Zivotno print()"<<endl;
    }
    // cisto virtuelna funkcija
    virtual float damage()=0;
    //
    virtual char tip()=0;

    char* getBoja(){
    return boja;
    }

    ~Zivotno(){
    cout<<"Default destructor Zivotno"<<endl;
    }
};
class Kuce:public Zivotno{
private:
    char rasa[15];
    bool daliKasa;
public:
    Kuce(){
    //cout<<"Default constructor Kuce"<<endl;
    }
    Kuce(char boja[],float tezina,char rasa[],bool daliKasa):Zivotno(boja,tezina){
    //cout<<"Parameter constructor Kuce"<<endl;
    // ovie gi pishuvame ako nemavme constructor od Zivotno
    //strcpy(this->boja,boja);
    //this->tezina=tezina;
    strcpy(this->rasa,rasa);
    this->daliKasa=daliKasa;
    }

    // preoptovaruvame cisto virtuelnata funkcija
    float damage(){
    if(tezina>20){
        return 30;
    }else{
        return 15;
    }
    }

    void print(){
    cout<<"Kuce "<<boja<<" "<<tezina<<" "<<rasa<<" "<<daliKasa<<endl;
    }

    char tip(){
    return 'k';
    }
    ~Kuce(){
    //cout<<"Default destructor Kuce"<<endl;
    }
};

class Petel:public Zivotno{
private:
    bool daliKukurika;
public:
    Petel(){
    //cout<<"Default constructor Petel"<<endl;
    }
    Petel(char boja[],float tezina,bool daliKukurika):Zivotno(boja,tezina){
    //cout<<"Parameter constructor Petel"<<endl;
    // ovie gi pishuvame ako nemavme constructor od Zivotno
    //strcpy(this->boja,boja);
    //this->tezina=tezina;
    this->daliKukurika=daliKukurika;
    }

    // override na Zivotno.print();
    void print(){
    cout<<"Petel "<<boja<<" "<<tezina<<" "<<daliKukurika<<endl;
    }

    char tip(){
    return 'p';
    }

    float damage(){
    if(daliKukurika){
        return 10;
    }else{
        return 5;
    }
    }

    ~Petel(){
    //cout<<"Default destructor Petel"<<endl;
    }
};

void printZivotni(Zivotno **niza,int n){
for(int i=0;i<n;i++){
    niza[i]->print();
    cout<<niza[i]->damage()<<endl;
}
}

void kuceVSpetel(Zivotno **niza,int n){
int brojKucinja=0;
int brojPetli=0;
for(int i=0;i<n;i++){
    // prva opcija
    Kuce *pK=dynamic_cast<Kuce*>(niza[i]);
    // ako pokazuvacot ne e 0 uspeshno sme kastirale
    if(pK!=0){
        brojKucinja++;
    }
    Petel *pP=dynamic_cast<Petel*>(niza[i]);
    if(pP!=0){
        brojPetli++;
    }
    // vtora opcija
    if(niza[i]->tip()=='k'){
        brojKucinja++;
    }else if(niza[i]->tip()=='p'){
        brojPetli++;
    }
}
cout<<"Kuce "<<brojKucinja<<":"<<brojPetli<<" Petel"<<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<<"Zivotno so najvekje damage"<<endl;
niza[pamtiIndex]->print();
}

void vkupenDamage(Zivotno **niza,int n){
float suma=0;
for(int i=0;i<n;i++){
    suma+=niza[i]->damage();
}
cout<<"Prosecniot damage e "<<suma/n<<endl;
}

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

void siteBeliZivotni(Zivotno **niza,int n){
for(int i=0;i<n;i++){
    if(strcmp(niza[i]->getBoja(),"bela")==0){
        niza[i]->print();
    }
}
}
int main(){
// obicna zivotno niza
//Zivotno niza[3];
// dinamicki alocirana niza
//Zivotno *niza=new Zivotno[3];
Zivotno **niza=new Zivotno*[4];
niza[0]=new Kuce("crna",15,"dzukela",false);
niza[1]=new Petel("bela",2,true);
niza[2]=new Kuce("bela",20,"labrador",true);
niza[3]=new Petel("crvena",5,false);
//printZivotni(niza,4);
//kuceVSpetel(niza,4);
//najvekjeDamage(niza,4);
//vkupenDamage(niza,4);
//siteZivotniNadX(niza,4,10);
siteBeliZivotni(niza,4);
return 0;
}

/*
class DebitCard{
protected:
    char *name;
    float balance;
    long int cardID;
public:
    DebitCard(){
    //delete []name;
    name=new char[0];
    }
    DebitCard(char *name,float balance,long int cardID){
    this->name=new char[strlen(name)+1];
    strcpy(this->name,name);
    this->balance=balance;
    this->cardID=cardID;
    }

    void print(){
    cout<<name<<" balance: "<<balance<<endl;
    }

    void deposit(float amount){
    this->balance+=amount;
    }

    DebitCard &operator+=(float amount){
    this->balance+=amount;
    return *this;
    }

    void withdraw(float amount){
    if(amount>balance){
        cout<<"Not enough credits"<<endl;
    }else{
        balance-=amount;
    }
    }
};

class CreditCard:public DebitCard{
private:
    int limit;
public:
    CreditCard(){}
    CreditCard(char *name,float balance,long int cardID,int limit):DebitCard(name,balance,cardID){
    this->limit=limit;
    }

    void withdraw(float amount){
    if(amount>balance+limit){
        cout<<"Not enough credits"<<endl;
    }else{
        balance-=amount;
    }
    }
    ~CreditCard(){}
};
int main(){
DebitCard random("Petar",250,1765432199);
random.print();
cout<<"Adding 2500"<<endl;
random+=2500;
random.print();
random.withdraw(3000);
random.withdraw(2000);
random.print();

CreditCard random2("Petar2",250,1765432199,20000);
random2.print();
cout<<"Adding 20000"<<endl;
random2+=20000;
random2.print();
random2.withdraw(50000);
random2.withdraw(30000);
random2.print();
return 0;
}