class Basis
{
    public:
        virtual void Funktion(void) = 0;
};

class Abgeleitet:public Basis
{
    public:
        void Funktion(void){/*...*/};
        void Funktion2(void){/*...*/};
};

Ich hab folgendes Problem:

Abgeleitet Abg;
Basis* pBasis = new Abgeleitet;
pBasis = &Abg;

pBasis->Funktion() aufzurufen ist kein Problem,aber ich will auch pBasis->Funktion2 aufrufen können. Dabei krieg ich aber immer eine Fehlermeldung.
Ist das überhaupt möglich pBasis->Funktion2() aufzurufen und wenn ja wie?

Danke

struct foo
{
    virtual void func_first() { std::clog << "foo::func() called" << std::endl;
};

struct bar : public foo
{
    void func_first() { std::clog << "bar::func() called" << std::endl;
    void func_second() { std::clog << "bar::func() called" << std::endl;
};

int main()
{
    foo* ptr_instance(new bar);
    foo->func_first();
    static_cast<bar*>(ptr_instance)->func_second();
}

...
}

(2) Casten.

Aber bitte richtig. Für einen Downcast in der Hierachie sollte man dynamic_cast verwenden.

cu André

aber da ich glaube, dass du das wohl weißt: solange man sich sicher ist, dass die bedingungen zutreffen, spricht imo nichts gegen den static_cast , wobei man sich dann natürlich die frage stellen sollte, warum überhaupt mit einem zeiger auf die basis arbeiten?

...

...
    static_cast<bar*>(ptr_instance)->func_second();
}

...
}

Naja, das funktioniert ja auch komplett ohne "func_first":

struct foo
{
    virtual ~foo() {}
};

struct bar : public foo
{
    void func_second() { std::clog << "bar::func() called" << std::endl;
};

int main()
{
    foo* ptr_instance(new bar);
    static_cast<bar*>(ptr_instance)->func_second();
}

Ich denke, die (saubere) Antwort auf die eigentliche Frage

Programmierer schrieb:

...
Ist das überhaupt möglich pBasis->Funktion2() aufzurufen und wenn ja wie?...

hat Vorden eigentlich schon gegeben: Ohne virtual besser gar nicht !

Gruß,

Simon2.

solange foo keine virtuelle basis von bar ist und der zeiger tatsächlich auf bar zeigt, ist ein static_cast durchaus erlaubt.

aber da ich glaube, dass du das wohl weißt: solange man sich sicher ist, dass die bedingungen zutreffen, spricht imo nichts gegen den static_cast , wobei man sich dann natürlich die frage stellen sollte, warum überhaupt mit einem zeiger auf die basis arbeiten?

Aber wehe es kommen mehrere konkrete Klassen an dieser Stelle ins Spiel.
Sorry, ich ziehe in dem Fall Sicherheit der Performance vor (Und sofern auch nur die Chance existiert das der Zeiger nicht auf die bei static_cast angegebene Klasse verweist, ist ein dynamic_cast definitiv der richtige Weg).
Da hier durchaus auch Anfänger mitlesen, möchte ich schlicht und ergreifend vermeiden das diese mit unnötigen und schwer auffindbaren Fehlern konfrontiert werden!

Performance mag eine gut gemeinte Option sein, aber am Anfang sollte immer die Sicherheit gelten.

cu André