Ich habe folgendes Problem:

class object{

void foo();

};

class ErbeI: public object{

void ErbeISpezifischeFunktion();

};

class ErbeII: public object{
(...)
};

//später im main

vector<object> vecObjects;

ErbeI erbI;
vecObjects.push_back(erbI);

ErbeII erbII;
vecObjects.push_back(erbII);

//Somit werden Objekte, die in den Vektor "gesteckt" werden und Erben von object sind gesliced

Es ist so, dass ich einen Vektor erstellen möchte, der alle Eigenschaften der Erben von object (z.B. ErbeISpezifischeFunktion()) berücksichtigt.

Gibt es eine Möglichkeit, dies zu erreichen?

Mit freundlichen Grüßen
heringsalat100

das geht nur mit Zeigern, d.h.

vector<object*> vecObjects;

so daß du die einzelnen Objekte dann per "new" erstellen mußt (und nach Benutzung dann wieder mittels "delete" freigeben).
Falls du die Objekte in mehreren Containern verwalten willst, dann kannst du auch einen shared_ptr (aus boost) verwenden, welcher die automatische Freigabe durchführt, falls kein Objekt mehr referenziert wird.

vector<derived1> foo(3);
vector<derived2> bar(3);

vector<base*> foobar;

foobar.push_back(&foo[0]);
foobar.push_back(&foo[1]);
foobar.push_back(&foo[2]);
foobar.push_back(&bar[0]);
foobar.push_back(&bar[1]);
foobar.push_back(&bar[2]);

machen. Dann sind die Besitzverhältnisse der Pointer und Objekte klar, ohne dass du großen Mehraufwand hättest.

Um das mal klarer zu machen: Auch wenn das oftmals mit new benutzt wird, ist dies keineswegs zwingend. Du darfst auch gerne so etwas wie

vector<derived1> foo(3);
vector<derived2> bar(3);

vector<base*> foobar;

foobar.push_back(&foo[0]);
foobar.push_back(&foo[1]);
foobar.push_back(&foo[2]);
foobar.push_back(&bar[0]);
foobar.push_back(&bar[1]);
foobar.push_back(&bar[2]);

machen. Dann sind die Besitzverhältnisse der Pointer und Objekte klar, ohne dass du großen Mehraufwand hättest.

Schöne Idee, wäre ich nicht drauf gekommen

Aber wenn ich dem Lösungsvorschlag von SeppJ folge:

(PS: ich habe in der Klasse ErbeI einen int var hinzugefügt)

ErbeI erbI;
erbI.var = 5;

vector<ErbeI> foo(3,erbI);

vector<object*> foobar; 

foobar.push_back(&foo[0]);
foobar.push_back(&foo[1]);
foobar.push_back(&foo[2]);

cout<<foobar[0]->var<<endl;

...wird mir vom Compiler gesagt, dass die Klasse object keine Variable mit dem Namen "var" besitzt, da der Vektor ja sogesehen auch nur für object ist.

Das stimmt ja, aber mein Ziel ist es, auch auf die Funktionen, Variablen etc. der erbenden Klassen zugreifen zu können.
Ich könnte natürlich in diesem Fall auf den Vector foo zurückgreifen, aber dies wäre ja ein zweiter Vector, ich habe aber eigentlich vor, einen einzigen Vektor mit allen Eigenschaften der jeweiligen Objekte zu erstellen.

Oder mache ich hier beim Zugriff auf die Eigenschaften der Erben einen Fehler?

Eine Rückmeldung würde mich erfreuen.

Aber wie ich dir auch schon gesagt habe, hast du vermutlich ein Problem das viel einfacher gelöst werden kann. Denn diese Art der Programmierung deutet sehr oft auf ein grundlegendes Designproblem hin. Es sollte fast nie nötig sein, den Typ eines Objektes zur Laufzeit zu bestimmen.

Zu den typeids:

nehmen wir mal an, ich würde typeid verwenden, wie müsste das Programm dann lauten?

Die vorangegangenen Beispiele sollten nur die Problemstellung, die ich meinte, vereinfachen, aber ich werde jetzt mal explizit:

Also:

Momentan bin ich dabei, ein 2D-Vogelperspektiven-Spiel zu programmieren. Dieses Spiel beinhaltet u.a.

|graphicsobject|->|object|->|usable_ob |->|fridge|

(unvollständig)

Dazu gibt es eine map-class, welche wegen der Flexibilität auf Vektoren basieren soll.

So:
Nun, wenn ich mit meinem Männchen z.B. einen fridge benutze und etwas esse, ändert sich die Menge an Essen im fridge.

Aber da meine Map ja nur object und keinen fridge oder sonstiges kennt, da sie ja aus objects besteht, kann ich auf die Variable Menge beim fridge nicht zugreifen.

Habe ich jetzt mein eigentliches Problem dargestellt?

Habe ich jetzt mein eigentliches Problem dargestellt?

Jupp. Und ich bin überzeugter denn je, Polymorphie wäre die Lösung.

Erstmale danke, dass du immer noch rückantwortest!

Nehmen wir dann an, ich nehme Polymorphie.

Inwiefern muss ich virtual benutzen, um meine Variable "Menge" vom "fridge" auch in Vektoren der Klasse "object" berücksichtigen zu können?

class graphicsobject{...};
class object: public graphicsobject{...};
class usable_ob: public object{...};
class fridge: public usable_ob{int Menge;};

class usable_object
{
public:
  virtual void use(Hero &)=0;
  virtual void describe() const =0;
  virtual ~usable_object()=0;
};

usable_object::~usable_object() {}

class fridge: public usable_object
{
  unsigned number_of_apples;
public:
  fridge(unsigned number_of_apples): number_of_apples(number_of_apples) {}
  virtual void describe() const
  {
    if (number_of_apples)
      cout << "Ein Kühlschrank mit " <<  number_of_apples << "Äpfeln.\n";
    else
      cout << "Ein leerer Kühlschrank.\n";
  }
  virtual void use(Hero& hero)
  {
    if (number_of_apples)
      {
        cout << "Du isst einen Apfel. Du fühlst dich stärker.\n";
        --number_of_apples;
        hero.increase_health(1);
      }
    else
      cout << "Der Kühlschrank ist leer.\n";
  }
  virtual ~fridge() {}
};

Aber dennoch danke an alle, die geantwortet haben!