komme im Moment leider nicht mehr weiter, habe eine abgeleitete Klasse bzw. mehrere und muss auf die Basisklasse zugreifen und will nun in der abgeleiteten Klasse eine Variable als Pointer auf die Basisklasse erstellen, kann mir bitte einer verraten wie das funktioniert?

Wenn ich einen Pointer anlege muss ich ja die Basisklasse einbinden was dann meiners Erachtens eine Endlosschleife ergibt da dann auf jeden Fall massen Fehler entstehen...

Danke
Niels

class Basis {
public:
   int a;
private:
   int b;
};

class Abgeleitet {
public:
   void f() { cout << a; }
   void g() { cout << b; } // Compilefehler: Zugriff verboten
};

Wenn Du natürlich (was aber mindestens "ungeschickt" ist) die Elemente "verdeckt" hast, musst Du sie mit dem Namen der Basisklasse vorher spezigizieren....

Beispiel:

class Basis {
public:
   int a;
};

class Abgeleitet {
public:
   int a;
   void f() { cout << a; } // gibt Abgeleitet::a aus
   void g() { cout << Basis::a; } // gibt Basis::a aus
};

Gruß,

Simon2.

hm ander schreiben:

Welt
erstellt
Ameisenbau (soll Pointer auf die Welt haben)
erstellt
Ameisen (soll Pointer auf Ameisenbau haben)
-Königin
-Arbeiter
-...

So, nu stimmt auch das mit dem Includen.

leicht OT: Ich hoffe, Ameisenbau und Ameise erben nicht von Welt und Ameise nicht von -bau, oder ?

Entweder arbeitest Du mit Pointern (wenn die Kopplung lockerer ist) oder mit Referenzen (feste Kopplung).

In diesem Fall schenen ir Referenzen gar nicht so dumm, weil wohl kein Ameisenbau die Welt wechselt (oder vor der Welt entsteht und erst nachträglich mit ihr verbunden wird) und das evtl. auch für die Ameisen und ihren Bau gilt (da bin ich mir aber nicht so sicher).
Der Vorteil ist: Du brauchst Dir in den Ameisenbau-Funktionen nie mehr Gedanken darüber machen, ob der Welt* geüllt ist, oder nicht. Außerdem weiß ein Anwender von Ameisenbau auf einen Blick, dass er zuerst eine Welt schaffen muss, bevor er einen Ameisenbau anlegen kann.

Gruß,

Simon2.

OT: Wie ist der Befehl um den Klassennamen zu kriegen? ^^

genau so ist es, Welt eigenständig, Ameisenbau eigenständig und nur Arbeiter und Königin sind von Ameise abgeleitet ...

[ED WOOD] PEEEEEEEERFECKT !![/ED WOOD];)

Gamewalker schrieb:

Wie kriege ich nun nen Pointer auf den Erzeuger? ^^...

Beim Erzeugen mitgeben...

class Ameisenbau {
   Welt& meineWelt;
public:
   Ameisenbau(Welt& erzeugendeWelt) : meineWelt(erzeugendeWelt) {}
};

int main() {
   Welt welt;
   Ameisenbau Bau(welt);
...

Übrigens: Ich würde "die Ameisenerzeugermimik" nicht in der Ameise verdrahten, weil damit prinzipiell jede Ameise das könnte und man es umständlich für alle Nichtköniginnen verbieten müsste.

class Ameise {
public:
   Ameise(Ameisenbau& bau) : meinBau(bau) {}
   void laufen();
   virtual ~Ameise() {} // virtual Dtr zeigt: Kannst von mir ableiten !
};

class Ameisenerzeuger {
public:
   Ameise* erzeugeAmeise(AmeisenBau& bau, int ameisenTyp);
};

class Koenigin : public Ameise, public Ameisenerzeuger {
public:
   Koenigin(Ameisenbau& bau) : Ameise(bau) {}
};

class Arbeiter : public Ameise {
public:
   void arbeite();
};

Ameise* Ameisenerzeuger::erzeugeAmeise(AmeisenBau& bau, int ameisenTyp) { 
  if(ameisenTtyp = Arbeiter) return new Arbeiter(bau); //natürlich besser mit enums/switch
  if(ameisenTyp = Koenigin) return new Koenigin(bau);
}

Ach ja: Es gibt typeid - allerdings:
1.) ist IIRC der entstehende String nicht standardisiert, so dass man ihn nicht in einem Programm verdrahten sollte (wenn, dann im Vergleich mit "typeid Klasse")
2.) Zu Testzwecken noch ganz OK, ist sowas üblicherweise ein Zeichen einer Designschwäche, wenn man etwas derartiges braucht. Ein wenig besser der dynamic_cast - gut ist nur, wenn man ganz ohne auskommt.

Gruß,

Simon2.

#include "CAntHeap"; //meine hier
class CAnt
{
public:
   CAnt(void);
   CAnt(CAntHeap* MyHeap);
   ~CAnt(void);

private:
   CAntHeap* m_MyHeap;
}

mal ein bisschen vereinfacht.

#include "CAnt";

class CQueen : public CAnt
{
public:
   CQueen(void);
   ~CQueen(void);

   DoProduceEgg()
   {
      m_MyHeap->NewAnt();
   }
}

#include "CAnt";

class CAntHeap
{
public:
   CAntHeap();
   ~CAntHeap();

   NewAnt();

private:
   list<CAnt*> m_lAnts;
}

Wenn ich das mache kommen Haufenweise Fehler.

//#include "CAntHeap"; //meine hier
class CAntHeap;
class CAnt
{
public:
   CAnt(void);
   CAnt(CAntHeap* MyHeap);
   ~CAnt(void);

private:
   CAntHeap* m_MyHeap;
}

mal ein bisschen vereinfacht.

#include "CAnt";

class CQueen : public CAnt
{
public:
   CQueen(void);
   ~CQueen(void);

   DoProduceEgg()
   {
      m_MyHeap->NewAnt();
   }
}

#include "CAnt";

class CAntHeap
{
public:
   CAntHeap();
   ~CAntHeap();

   NewAnt();

private:
   list<CAnt*> m_lAnts;
}