Vererbung

Hallo zusammen,

Ich habe eine Instanz Wilhelma von der Klasse "Zoo". In dieser Klasse habe ich einen Zeiger (ich hoffe das ist der richtige Begriff!) auf eine Variable vom Typ "Gehege", mit bis zu X Elementen. Gehege an sich ist wiederrum eine Klasse mit zwei abstrakten Funktionen, und hat zwei Kinder "Innen" und "Aussen".

//-----------------------------------------------//
// START //
//-----------------------------------------------//

class Zoo
{
      public:
         Zoo(int anzahl);
         ...

      private:
         Gehege *Liste;
};

//-----------------------------------------------//

Zoo::Zoo(int anzahl)
{
   Liste = new Gehege[anzahl];
}

//-----------------------------------------------//

int main(int argc, char* argv[])
{

   Wilhelma Zoo(5);

   return 0;
}

//-----------------------------------------------//
// ENDE //
//-----------------------------------------------//

Nun meine Fragen:

1.) Im Konstruktor von Zoo lege ich via new "Anzahl" Gehege-Klassen an. Wie kann ich nun aber (dynamisch!) festlegen, dass beispielsweise das erste und zweite Element vom Typ der Kinds-Klasse "Innen", die restlichen Anzahl-2 aber vom Typ "Aussen" sind?

2.) Wenn ich aus einer Funktion der Kinds-Klasse heraus auf eine Funktion der Klasse "Zoo" zugreifen? Schreibe ich "Zoo.funktion()", oder "Wilhelma.funktion()", oder noch anders?

3.) Kann ich herausfinden, die Adresse welchen Klassen-Kind-Types (Innen/Aussen) Liste[x], mit 0<x<Anzahl, beinhaltet?

Grüße,
CC

DarkLord

Um von einer der Gehege-Klassen auf die Wilhelma-Klasse zugreifen zu können musst du ihnen einen Zeiger auf die Zoo-Klasse übergeben, es sei denn du deklariertst die Klasse global. (davon rate ich aber ab) Dann kannst du per Zeiger auf die Zoo-Klasse zugreifen:

Wilhelma* ZooZeiger = DerÜbergebeneZooZeiger;
ZooZeiger->Funktion();

PS.: Du willst doch auf deine von dir schon deklaierte Klasse zugreifen oder?

Szull

also erstmal definierst du einen Zoo vom Typ Wilhelmina, korrekt müsste es heißen:

Zoo Wilhelmina(5);

zum Thema dynamisches Festlegen, hier zB immer abwechselnd Außen-/Innengehege:

int i;
Liste = new Gehege[anzahl];
if (Liste % 2) {
    for (i = 0; i <= anzahl/2; i++) Liste[2*i] = new Aussengehege;
    for (i = 0; i < anzahl/2; i++) Liste[2*i] = new Innengehege;
} else {
    for (i = 0; i < anzahl/2; i++) Liste[2*i] = new Aussengehege;
    for (i = 0; i < anzahl/2; i++) Liste[2*i+1] = new Innengehege;
}

zu 3.: Definiere noch einen int namens type in Gehege, diesen lässt du entweder G_AUSSEN oder G_INNEN(Konstanten) werden im jeweiligen Konstruktor, dann sagst du:

if (Liste[x].type == G_AUSSEN) {/*blabla*/}
else {/*blabla*/}

Ja, die Klasse (Zoo) wurde bereits deklariert.

Ich bin gerade etwas durcheinander...

Muss es ersteinmal nicht richtig heissen:

Zoo* ZooZeiger = DerÜbergebeneZooZeiger; // Also Zoo* anstatt Wilhelma* ?
ZooZeiger->Funktion();

Angenommen, ich möchte nun aus main heraus eine Funktion in der Gehege-Klasse aufrufen, samt Zeiger-Übergabe, dann schreibe ich doch:

main
{
   Zoo Wilhelma;
   Zoo* Zeiger = &Wilhelma;
   Wilhelma.Liste[x].function(int variable1, *Zeiger);
}

Aus der Gehege-Klasse kann ich dann doch folgendermaßen die Zoo-Class-Funktion "tuwas(int var)" aufrufen:

function(int variable1, *Zeiger)
{
   Zeiger->tuwas(int var);
}

Wo ist der Unterschied zwischen, bzw. wann verwende ich "->", wann "."?

Hat noch jemand eine Idee für die Frage 1?

Grüße,
CC

Ich sehe gerade, dass es in meinem Listing ganz oben richtig heissen muss:

Zoo Wilhelma(5);

Szull

zu '->' und '.': -> bedeutet nichts andres, als auf eine Variable/Funktion eines Zeigers zugreifst, zB:

Zoo* Zeiger;
Zeiger->tuwas();

'.' greift auf eine Variable/Funktion eines Nicht-Zeigers.

zu deinem 1.:

class Zoo {
private:
    Gehege **Liste;
public:
    Zoo(int);
    //..............//
}
Zoo::Zoo(int anzahl) {
    Liste = new *Liste[anzahl]
    if (anzahl >= 2) {
        Liste[0] = new Innengehege;
        Liste[1] = new Innengehege;
        for (int i = 2; i < anzahl; i++) Liste[i] = new Aussengehege;
    } else Liste[0] = new Innengehege;
}

geht nur wenn anzahl > 0.

zu deinen andren Problemen:

Zoo Wilhelma;
   Zoo* Zeiger = &Wilhelma;
   Wilhelma.Liste[x]->function(variable1, Zeiger); //Liste ist ein Array von Zeigern, dh Liste[x] ist ein Zeiger auf Gehege

Beim Aufrufen der Funktion übergibst du Argumente, dh das int vor variable1 muss weg. Zum Übergeben des Zeigers musst du den Zeiger selbst, nicht seinen Wert übergeben.
die Funktion function müsste so aussehen:

[cpp]
void function (int variable1, Zoo *Zeiger) {
Zeiger->tuwas(bereitsDeklarierteVariable);
}
[/cpp]

Schau dir am besten in deinem Buch/Tut noch mal den Unterschied zwischen Deklaration einer Funktion und ihrem Aufruf.