welche Möglichkeit habe ich, wenn eine Basisklasse mehrere abgeleitete Klassen besitzt, die allesamt eine DrawX() Funktion aufweisen? Wie weiß die Basisklasse, welche der abgeleiteten Klassen aufgerufen werden muss?

//Aufruf in der Basisklasse
DrawX(data);

//definition im header der basisklasse
virtual void DrawX(CByteArray &) PURE;

//definition in abgeleiteter klasseA
virtual void ProcessReceive(CByteArray &data);

//definition in abgeleiteter KlasseB
???? 
virtual void ProcessReceive(CByteArray &data);

Gruß
Konrad

BasisKlasse1::ProcessReceive(...);
  BasisKlasse2::ProcessReceive(...);

ich habe eine Basisklasse mit mehreren abgeleiteten Klassen, die allesamt diese Funktion besitzen. Und aus der Basisklasse möchte ich gern die richtige abgeleitete Klasse aufrufen.

Geht das auch mit einer zweiten Variable im Funktionsaufruf, die eindeutig kennzeichnen würde, dass es sich um KlasseA oder KlasseB handelt?

ProcessReceive(data, 1) -> abgeleitete Funktion in KlasseA aufrufen
ProcessReceive(data, 2) -> abgeleitete Funktion in KlasseB aufrufen

Wie müsste dann die Deklaration der abgeleiteten Klasse aussehen?

Konrad

So.

class A : public X 
{
protected:
   virtual void Process() PURE;
}

class B : public class A
{
protected:
  virtual void Process();

}

class C : public class A:
{
protected:
 virtual void Process();
}

Wie weiß die Basisklasse, welche der abgeleiteten Klassen aufgerufen werden muss?
...
Und aus der Basisklasse möchte ich gern die richtige abgeleitete Klasse aufrufen.

Da musst du nix machen. Sofern diese Funktion virtuell ist, wird die 'richtige' aufgerufen (die, welche dem Typ der Instanz entspricht).
Ausser du meinst mit 'richtige' was anderes.

Was ist PURE?

Wird wohl ein '= 0' Makro sein. => Weg damit!

Was ist PURE?

bedeutet lediglich, dass nur die abgeleiteten Klassen eine entsprechende Funktion (subclass) bereitstellen.

Jockelx schrieb:

Da musst du nix machen. Sofern diese Funktion virtuell ist, wird die 'richtige' aufgerufen (die, welche dem Typ der Instanz entspricht).
Ausser du meinst mit 'richtige' was anderes.

das Problem ist hier, dass beide abgeleiteten Klassen den gleichen Aufruf besitzen und ich diese Funktion nicht mittels eines Objects aufrufe.

virtual void Process(CByteArray &data);

und der Aufruf in der Basisklasse ist

Process(data);

und der Aufruf in der Basisklasse ist

Process(data);

Aber dieser Aufruf steht seinerseits innerhalb einer Memberfunktion; wäre Sie statisch, liesse sich das nicht kompilieren.
Also existiert doch ein Objekt und von diesem Objekt hängt ab, welche Variante aufgerufen wird.

Edit: Oder rufst du das im Konstruktor auf? Dann ginge das so tatsächlich nicht.

Richtig. Und in deinem Beispiel wir Process von class B bzw class C aufgerufen. Was genau willst du denn?

nein Process() wird innerhalb von der Klasse A (Basisklasse) aufgerufen -> die jetzt ebend entscheiden muss welche abgeleitete Klasse (B oder C) ausgewählt werden soll!

Richtig. Und in deinem Beispiel wir Process von class B bzw class C aufgerufen. Was genau willst du denn?

HÄ?!

Welchen Typ hat das Objekt denn?
Entweder es ist vom Typ B oder C und entsprechend wird die Funktion aufgerufen.

Fellhuhn schrieb:

Richtig. Und in deinem Beispiel wir Process von class B bzw class C aufgerufen. Was genau willst du denn?

nein Process() wird innerhalb von der Klasse A (Basisklasse) aufgerufen -> die jetzt ebend entscheiden muss welche abgeleitete Klasse (B oder C) ausgewählt werden soll!

Meinst Du vielleicht sowas?

struct A
{
   void doIt() {Process();}
   virtual void Process() = 0;
};

struct B : A
{
  virtual void Process() { cout << "B\n"; }
};

struct C : A
{
 virtual void Process() { cout << "A\n"; };
};

Wenn ja: Dann hast Du kein Problem, weil Du letztlich beim konkreten Aufruf trotzdem auf jeden Fall ein B- oder ein C-Objekt in der Hand hast (ein A-Objekt kannst Du ja nicht instantiieren, weil es abstrakt ist (=eine rein virtuelle Funktion hat)).

int main() {
   B b;
   b.doIt();
   C c;
   c.doIt();
   return 0;
}

Vielleicht machst Du Dir das Leben ein wenig einfacher, wenn Du zwischen einer Klasse (= Strukturfestlegung) und einem Objekt (oder Instanz) (= Datensatz, der dieser Strukturfestlegung gemaäß erzeugt wurde) unterscheidest.

BTW: Genau DAS ist der Sinn virtueller Funktionen.

Gruß,

Simon2.