classGegner.h

#ifndef CLASSGEGNER_H_INCLUDED
#define CLASSGEGNER_H_INCLUDED

#include <string>

class Gegner
{
    public:
        Gegner( std::string name, int gesundheit, int ruestung, int schnelligkeit );
        ~Gegner();
        std::string getName() const { return itsName; }
        void setName( std::string name );
        int getGesundheit() const { return itsGesundheit; }
        void setGesundheit( int gesundheit );
        int getRuestung() const { return itsRuestung; }
        void setRuestung( int ruestung );
        int getSchnelligkeit() const { return itsSchnelligkeit; )
        void setSchnelligkeit( int schnelligkeit );

    private:
        std::string itsName;
        int itsGesundheit;
        int itsRuestung;
        int itsSchnelligkeit;
};

class StaerkeGegner : public Gegner
{
    public:
        StaerkeGegner( std::string name, int gesundheit, int ruestung, int schnelligkeit, int staerke );
        ~StaerkeGegner();
        int getStaerke() const { return itsStaerke; }
        void setStaerke( int staerke );

    private:
        int itsStaerke;
};

class ZauberGegner : public Gegner
{
    public:
        ZauberGegner( std::string name, int gesundheit, int ruestung, int schnelligkeit, int zauberfaehigkeit );
        ~ZauberGegner();
        int getZauberfaehigkeit() const { return itsZauberfaehigkeit; }
        void setZauberfaehigkeit( int zauberfaehigkeit );

    private:
        int itsZauberfaehigkeit;
};

#endif // CLASSGEGNER_H_INCLUDED

classGegner.cpp

#include "classGegner.h"
#include <string>

using namespace std;

Gegner::Gegner( string name, int gesundheit, int ruestung, int schnelligkeit ):
    itsName( name ), itsGesundheit( gesundheit ), itsRuestung( ruestung), itsSchnelligkeit( schnelligkeit )
{
}

Gegner::~Gegner()
{
}

void Gegner::setName( string name )
{
    itsName = name;
}

void Gegner::setGesundheit( int gesundheit )
{
    itsGesundheit = gesundheit;
}

void Gegner::setRuestung( int ruestung )
{
    itsRuestung = ruestung;
}

void Gegner::setSchnelligkeit( int schnelligkeit )
{
    itsSchnelligkeit = schnelligkeit;
}

StaerkeGegner::StaerkeGegner( string name, int gesundheit, int ruestung, int schnelligkeit, int staerke ):
    itsStaerke( staerke )
{
    Gegner( name, gesundheit, ruestung, schnelligkeit );
}

StaerkeGegner::~StaerkeGegner()
{
}

void StaerkeGegner::setStaerke( int staerke )
{
    itsStaerke = staerke;
}

ZauberGegner::ZauberGegner( string name, int gesundheit, int ruestung, int schnelligkeit, int zauberfaehigkeit ):
    itsZauberfaehigkeit( zauberfaehigkeit )
{
    Gegner( name, gesundheit, ruestung, schnelligkeit );
}

ZauberGegner::~ZauberGegner()
{
}

void ZauberGegner::setZauberfaehigkeit( int zauberfaehigkeit )
{
    itsZauberfaehigkeit = zauberfaehigkeit;
}

Ich bekomme sehr viele Fehlermeldungen, ich denke jedoch, die beiden an denen es liegt sind diese hier:
classGegner.h Zeile 28 invalid use of undefined typ gegner
classGegner.h" Zeile 7 forward declaration of type class gegner
classGegner.h" Zeile 40 invalid use of type class gegner

die anderen fehlermeldungen beziehen sich auf die .cpp datei und hängen vermute ich mit den fehlern zusammen.

Ich kapiere es jedoch nicht, denn ich deklariere ja gegner bevor ich die davon abgeleiteten klassen deklariere.

Hoffe ihr könnt mir wieder einmal Helfen=)

Danke schonmal

Gruß fr33G

StaerkeGegner::StaerkeGegner( string name, int gesundheit, int  ruestung, int schnelligkeit, int staerke ):
    itsStaerke( staerke )
{
    Gegner( name, gesundheit, ruestung, schnelligkeit );
}

sollte doch eher

StaerkeGegner::StaerkeGegner( string name, int gesundheit, int  ruestung, int schnelligkeit, int staerke ):
    Gegner( name, gesundheit, ruestung, schnelligkeit ),
    itsStaerke( staerke )
{
}

heißen, oder? (Basisinitialisierung)

Hab beides geändert, uns nun läufts=)

Vielen Dank

Kann ich irgendwie im Programm abfragen ob ein Zeiger

Gegner* myGegner

ein Zeiger auf ein
ZauberGegner
oder auf ein StaerkeGegner ist?

also so auf die art

if( myGegner == ZauberGegner* )
//do something
elsle if( myGegner == StaerkeGegner* )
// do something

Danke schonmal=)

class Player {
};

class Gegner {
    virtual void damagePlayer( Player* )=0;
}

class RitterGegner : public Gegner {
    void damagePlayer( Player *p ) {
        p->chopHead();
    }
};

class ZauberGegner : public Gegner {
    void damagePlayer( Player* p ) {
        randomWizTransform(p);
    }
};

Ich hoffe es ist klar worauf ich hinaus will

dynamic_cast

Was oberträge ist und die Abfrage des return nach Hinzufügen einer neuen Klasse erweitert werden muss. Dann am besten noch in ner falschen Reihenfolge (Basisklasse vor abgeleiteter Klasse), und schon ist die Kacke am Dampfen.

Auf jeden Fall mal danke=)

Und ja ich weiß wo du drauf hinaus willst