#ifndef CLASSITEMS_H_INCLUDED
#define CLASSITEMS_H_INCLUDED

#include <string>

enum ItemTyp
{
    WAFFE,
    ZAUBERWAFFE,
    RUESTUNG,
    TRANK
};

class Item
{
    public:
        Item( ItemTyp typ, int verfuegbarkeit, std::string name );
        virtual ~Item();
        virtual ItemTyp getItemTyp() const { return itsTyp; }
        virtual int getVerfuegbarkeit() const { return itsVerfuegbarkeit; }
        virtual std::string getName() const { return itsName; }
        virtual int getSchaden() const = 0; // Hier schon deklariert, damit ich im Inventar allgemeint Items speichern kann, sonst fehlen die Funktionen da Zeiger auf Item
        virtual int getSchnelligkeit() const = 0;
        virtual int getRuestung() const = 0;
        virtual int getGesundheit() const = 0;
        virtual int getZauberfaehigkeit() const = 0;

    private:
        ItemTyp itsTyp;
        int itsVerfuegbarkeit;
        std::string itsName;
};

class WaffenItem : public Item
{
    public:
        WaffenItem( int verfuegbarkeit, int schaden, int schnelligkeit, std::string name );
        virtual ~WaffenItem();
        virtual int getSchaden() const { return itsSchaden; }
        virtual int getSchnelligkeit() const { return itsSchnelligkeit; }

    protected:
        int itsSchaden;
        int itsSchnelligkeit;
};

class Schwert : public WaffenItem
{
    public:
        Schwert( int verfuegbarkeit );
        virtual ~Schwert();
        virtual int getSchaden() const { return itsSchaden; }
        virtual int getSchnelligkeit() const { return itsSchnelligkeit; }
};

class Messer : public WaffenItem
{
    public:
        Messer( int verfuegbarkeit );
        virtual ~Messer();
        virtual int getSchaden() const { return itsSchaden; }
        virtual int getSchnelligkeit() const { return itsSchnelligkeit; }
};

class RuestungsItem : public Item
{
    public:
        RuestungsItem( int verfuegbarkeit, int ruestung, int schnelligkeit, std::string name );
        virtual ~RuestungsItem();
        virtual int getRuestung() const { return itsRuestung; }
        virtual int getSchnelligkeit() const { return itsSchnelligkeit; }

    protected:
        int itsRuestung;
        int itsSchnelligkeit;
};

class Kopfschutz : public RuestungsItem
{
    public:
        Kopfschutz( int verfuegbarkeit );
        virtual ~Kopfschutz();
        virtual int getRuestung() const { return itsRuestung; }
        virtual int getSchnelligkeit() const { return itsSchnelligkeit; }
};

class TrankItem : public Item
{
    public:
        TrankItem( int verfuegbarkeit, int gesundheit, std::string name );
        virtual ~TrankItem();
        virtual  int getGesundheit() const { return itsGesundheit; }

    protected:
        int itsGesundheit;
};

class HeilTrank20 : public TrankItem
{
    public:
        HeilTrank20( int verfuegbarkeit );
        virtual ~HeilTrank20();
        virtual int getGesundheit() const { return itsGesundheit; }
};

class ZauberItem : public Item
{
    public:
        ZauberItem( int verfuegbarkeit, int zauberfaehigkeit, std::string name );
        virtual ~ZauberItem();
        virtual int getZauberfaehigkeit() const { return itsZauberfaehigkeit; }

    protected:
        int itsZauberfaehigkeit;
};

class Zauberverstaerker3 : public ZauberItem
{
    public:
        Zauberverstaerker3( int verfuegbarkeit );
        virtual ~Zauberverstaerker3();
        virtual int getZauberfaehigkeit() const { return itsZauberfaehigkeit; }
};

#endif // CLASSITEMS_H_INCLUDED

classItems.cpp

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

using namespace std;

Item::Item( ItemTyp typ, int verfuegbarkeit, string name ):
    itsTyp( typ ), itsVerfuegbarkeit( verfuegbarkeit ), itsName( name )
{
}

Item::~Item()
{
}

WaffenItem::WaffenItem( int verfuegbarkeit, int schaden, int schnelligkeit, string name ):
    Item( WAFFE, verfuegbarkeit, name ), itsSchaden( schaden ), itsSchnelligkeit( schnelligkeit )
{
}

WaffenItem::~WaffenItem()
{
}

Schwert::Schwert( int verfuegbarkeit ):
    WaffenItem( verfuegbarkeit, 5, 2, "Schwert" )
{
}

Schwert::~Schwert()
{
}

Messer::Messer( int verfuegbarkeit ):
    WaffenItem( verfuegbarkeit, 3, 3, "Messer" )
{
}

Messer::~Messer()
{
}

RuestungsItem::RuestungsItem( int verfuegbarkeit, int ruestung, int schnelligkeit, string name ):
    Item( RUESTUNG, verfuegbarkeit, name ), itsRuestung( ruestung ), itsSchnelligkeit( schnelligkeit )
{
}

RuestungsItem::~RuestungsItem()
{
}

Kopfschutz::Kopfschutz( int verfuegbarkeit ):
    RuestungsItem( verfuegbarkeit, 3, 2, "Kopfschutz" )
{
}

Kopfschutz::~Kopfschutz()
{
}

TrankItem::TrankItem( int verfuegbarkeit, int gesundheit, string name ):
    Item( TRANK, verfuegbarkeit, name ), itsGesundheit( gesundheit )
{
}

TrankItem::~TrankItem()
{
}

HeilTrank20::HeilTrank20( int verfuegbarkeit ):
    TrankItem( verfuegbarkeit, 20, "Heil-Trank-20" )
{
}

HeilTrank20::~HeilTrank20()
{
}

ZauberItem::ZauberItem( int verfuegbarkeit, int zauberfaehigkeit, string name ):
    Item( ZAUBERWAFFE, verfuegbarkeit, name ), itsZauberfaehigkeit( zauberfaehigkeit )
{
}

ZauberItem::~ZauberItem()
{
}

Zauberverstaerker3::Zauberverstaerker3( int verfuegbarkeit ):
    ZauberItem( verfuegbarkeit, 3, "Zauberverstaerker3" )
{
}

Zauberverstaerker3::~Zauberverstaerker3()
{
}

Mein problem, wenn ich in meinem Programm ein Objekt erstellen will, zum Beispiel Kopfschutz, sagt er mir dass die Funktionen wie getSchaden und so nur abstract sind, aber ich hab sie ja für jede Klasse implementiert. Das komische ist, klasse Kopfschutz hat zum beispiel nur die Funktionen getRuestung und getSchnelligkeit, laut Fehlermeldung sagt er aber getSchaden und getGesundheit sind abstrakt, dabei werden diese funktionen gar nicht bei der klasse benötigt.
bei klasse schwert, das gleiche.

Mach ich das = 0 weg, so dass sie nicht mehr abstrakt sind, bekomm ich beim linken für jede funktion den fehler undefined reference to get...

Hoffe ihr könnt mir helfen, weiß net mehr weiter=(

Also:
Klassenhierarchie passt schon so, nur nicht dass Item schon Informationen aller jemals abgeleiteten Klassen bietet.

Folgende Lösungen:

1. Für jede Unterart von Items werden separate Listen geführt. Also eine für Waffen, eine für Kopfschutz, usw.
2. Du führst nur eine Liste, machst bei Zugriffen nen dynamic_cast auf die benötigte Klasse und verwendest deren spezielle Methoden

In deinem Fall ist 1) absolut kein Problem und sollte verwendet werden.

Meine Analyse: Schlechtes Design. Wenn Kopfschutz keinen Schadenswert hat, dann braucht es auch keine Methode um auf diesen zuzugreifen. Wenn jedes item einen Schadenswert hat (und dieser bei Kopfschutz Null ist), dann musst du trotzdem die zugehörige Methode implementieren. Du könntest beispielsweise in RuestungsItem eine Methode getSchaden() definieren, die einfach immer 0 zurückgibt. So würde ich es machen.

Hab jetzt das abstrakte weggemacht und in der Basisklasse Item alle Funktionen mit return 0 implementiert.

Ich finde ich kann es so lassen, oder hast du ( SeppJ ) eine bessere Idee für ein Design:-P

Weil die Idee die ich hätte wird denk ich net funzen, wenn ich die Funktionen wie getSchaden dann nur in WaffenItem mache, dann meckert er ja wenn ich ein zeiger auf item mache und ein schwert erstellen will, dass Item keine Funktion hat die getSchaden heißt, meine ich hätte das schon ganz am Anfang so probiert:D

Gruß freeG

Ich finde ich kann es so lassen, oder hast du ( SeppJ ) eine bessere Idee für ein Design:-P

Ich sehe da zwei Designphilosophien, welche von beiden passt, kannst nur du entscheiden:

1. Jedes Item hat alle Eigenschaften. Dies ist ungefähr das was du jetzt hast. finde ich persönlich eher unpassend. Minimalbeispiel:

#include<iostream>
#include<string>
#include<sstream>
#include<vector>
using namespace std;

class Item{
private:
  virtual int get_schutz()=0;
  virtual int get_schaden()=0;
  virtual string get_name()=0;
public:
  string eigenschaften()
  {
    stringstream temp;
    temp<<"Dies ist ein "<<get_name()<<". Ein "<<get_name()<<" bietet "<<get_schutz()<<" Schutz und macht "<<get_schaden()<<" Schaden.";
    return temp.str();
  }
};

class Waffe: public Item
{
  virtual int get_schutz()
  {
    return 0;
  }
};

class Schwert: public Waffe
{
  virtual int get_schaden()
  {
    return 10;
  }
  virtual string get_name()
  {
    return "Schwert";
  }  
};

class Ruestung: public Item
{
  virtual int get_schaden()
  {
    return 0;
  }
};

class Kopfschutz: public Ruestung
{
  virtual int get_schutz()
  {
    return 5;
  }
  virtual string get_name()
  {
    return "Kopfschutz";
  }  
};

int main()
{
  vector<Item*> items;
  items.push_back(new Schwert());
  items.push_back(new Kopfschutz());

  for (int i=0; i<items.size();++i)
    cout<<"Gegenstand "<<i<<": "<<items[i]->eigenschaften()<<endl;
}

Ausgabe:

Gegenstand 0: Dies ist ein Schwert. Ein Schwert bietet 0 Schutz und macht 10 Schaden.
Gegenstand 1: Dies ist ein Kopfschutz. Ein Kopfschutz bietet 5 Schutz und macht 0 Schaden.

2. Jedes Item hat wirklich nur die Eigenschaften, die es wirklich braucht. Diese Desingphilosophie halte ich für sauberer. Technisch gesehen macht ein Kopfschutz zwar 0 Schaden, aber wenn man alles aufzählt was ein Kopfschutz nicht macht, hat man eine unendlich lange Liste. Daher finde ich, dass eine Klasse nur Eigenschaften haben sollte, die diese auch tatsächlich auszeichnen.
Beispiel:

#include<iostream>
#include<string>
#include<sstream>
#include<vector>
using namespace std;

class Item{
protected:
  virtual string get_name()=0;
public:
  virtual string eigenschaften()=0;
};

class Waffe: public Item
{
  virtual int get_schaden()=0;
public:
  virtual string eigenschaften()
  {
    stringstream temp;
    temp<<"Dies ist ein "<<get_name()<<". Ein "<<get_name()<<" ist eine Waffe und macht "<<get_schaden()<<" Schaden.";
    return temp.str();
  }
};

class Schwert: public Waffe
{
  virtual int get_schaden()
  {
    return 10;
  }
  virtual string get_name()
  {
    return "Schwert";
  }  
};

class Ruestung: public Item
{
  virtual int get_schutz()=0;
public:
  virtual string eigenschaften()
  {
    stringstream temp;
    temp<<"Dies ist ein "<<get_name()<<". Ein "<<get_name()<<" ist ein Ruestungsteil und bietet "<<get_schutz()<<" Schutz.";
    return temp.str();
  }
};

class Kopfschutz: public Ruestung
{
  virtual int get_schutz()
  {
    return 5;
  }
  virtual string get_name()
  {
    return "Kopfschutz";
  }  
};

int main()
{
  vector<Item*> items;
  items.push_back(new Schwert());
  items.push_back(new Kopfschutz());

  for (int i=0; i<items.size();++i)
    cout<<"Gegenstand "<<i<<": "<<items[i]->eigenschaften()<<endl;
}

Ausgabe:
[code][Gegenstand 0: Dies ist ein Schwert. Ein Schwert ist eine Waffe und macht 10 Schaden.
Gegenstand 1: Dies ist ein Kopfschutz. Ein Kopfschutz ist ein Ruestungsteil und bietet 5 Schutz.
/code]

P.S.: Ja, ich weiß, dass meine Beispiele Speicherlöcher erzeugen und dass Klassen mit nur statischen Eigenschaften ziemlich witzlos sind. Aber ich bin mir sicher, dass der Threadersteller dies erkennen und verbessern kann. Soll ja nur ein Beispiel sein.

Ja ich denke aber auch dass ich wohl eher zu Version 2 tendiere=)
Lasse mir es nochmal durch den Kopf gehen.

Auf jeden Fall vieelen Dank=)