Abgeleitete Klassen über Basisklassen ansprechen?

MisterZ

Hallo,
mal angenommen, ich hätte eine Klasse, die von einer Basisklasse abgeleitet ist. Wenn ich einen Zeiger auf diese Klasse an eine Funktion übergebe, die die abgeleitete Klasse nicht kennt, aber die die Basisklasse kennt, kann ich dann problemlos Funktionen der abgeleiteten Klasse über die Basisklasse ansprechen?
Ein Beispiel:

class OBJECT
{
private:
  int x;
public:
  void setX(int zahl)
  {
    x = zahl;
  }

};

class AOBJECT : OBJECT
{
private:
  int xQuadrat;
public:
  void setX(int zahl)
  {
    x = zahl;
    xQuadrat = zahl*zahl;
  }

};

void xSetzen(void* P_klasse, int x)
{
  (*OBJECT)P_klasse->setX(x);
}

void erstellen()
{
  AOBJECT *P_aobject = new(AOBJECT);
  xSetzen((void*)P_aobject, 5);

}

Ist das prinzipiell möglich und sinnvoll, oder führt das zu Fehlern, oder gibt es bessere Alternativen?

Danke.

c++eus

Hi,

das schreit geradezu nach einer virtual-Deklaration:

class Object
{
    virtual void Print()
    {
    cout << "Basis";
    }
}
class A_Object : public Object
{
    void Print()
    {
    cout << "Abgeleitet";
    }
}
int main()
{
Objet* b = new Object();
A_Object a;
b->Print;
b = &a
}

Ausgabe: BasisAbgeleitet

Das ist sinvoll, und beeinflusst die Laufzeit kaum
Hintergrund: Der Compiler legt eine Tabelle aus Zeigern auf die Funktionen der Abgeleiteten Klasse an.

MisterZ

Läuft das ohne Speicherprobleme? Dann kann ich also tausende abgeleiteter Klassen mit verschiedenen Funktionen in einer Liste speichern, ohne die ganzen Klassen zu kennen? (sofern sie die selben Funktionen verwenden) Ist es sinnvoll, das so zu machen?

c++eus

Hi,

du kannst alle Klassen der Liste in die gemeinsame Basisklasse konvertieren, und so alle Methonen ansprechen, die auch schon in der Basisklasse deklariert sind.
#edit#

das ganze muss über einen Basisklassenzeiger laufen, der auf eine abgeleitete Klasse zeigt (oder auf die Basisklasse), deren Basisklassenmethoden als virtual deklariert sind. Der Compiller wählt sich immer die "passende" Methode aus.

MisterZ

Wunderbar, Danke für die Info! Werd ich demnächst mal im größeren Rahmen testen!

Christoph

Mal was anderes:
Was bringt es, den Zeiger vor dem Funktionsaufruf in void* zu konvertieren, nur um ihn in der Funktion wieder zurückzucasten?

c++eus

Hi,

Man kann Funktionen programmieren, die mit verschiedenen Dateitypen aufgerufen werden kann. Dies wird in C z.B. in der Funktion Qsort verwendet. In C++ ist das meiner Meinung nicht mehr nötig(Templates, Überladung)

MisterZ

@cd9000
Stimmt, bringt nichts. Ich war mir nur nicht ganz sicher, ob der Compiler einen solchen Typecast akzeptiert.

@c++eus
Geht auch, aber was ist eigentlich schneller? Typecast oder Template? Und wie kann ich das mit Templates realisieren?

c++eus

MisterZ schrieb:

@c++eus
Geht auch, aber was ist eigentlich schneller? Typecast oder Template? Und wie kann ich das mit Templates realisieren?

Hi,

//Template:
// verwendung: Objekte, für die der >-Operator überladen ist.
template<class T> T func(T i, T j) {
    if(i < j)
    {
        return j;
    }else return i;
}
//Überladung:
int func(int i, int j) {
    if(i < j)
    {
        return j;
    }else return i;
}
double func(double i, double j) {
    if(i < j)
    {
        return j;
    }else return i;
}

Ich hoffe, das hilft dir...(hab die Überladung noch mit eingebaut.)
Template ist besser, da Typensicher (und ist void* vorzuziehen.)