Ist es möglich eine virtuelle Funktion, welche ich in einer Basisklasse habe komplett zu überladen, d.h. auch Parameter ändern??

Beispiel:

class A
{
    virtual void tuWas();
};

class B : public class A
{
    void tuWas(Objekt hiermit);
};

habe nämlich bisher immer nur gesehen, dass wenn man eine virtuelle Funbktion überlädt, dann mit genau dem selben funktionskopf.

habe nämlich bisher immer nur gesehen, dass wenn man eine virtuelle Funbktion überlädt, dann mit genau dem selben funktionskopf.

Du verwechselst überschreiben mit überladen.

Toudinho schrieb:

habe nämlich bisher immer nur gesehen, dass wenn man eine virtuelle Funbktion überlädt, dann mit genau dem selben funktionskopf.

Du verwechselst überschreiben mit überladen.

Ich glaube nicht, dass er es verwechselt, sondern er hätte in diesem Fall lieber "überschreiben" statt "überladen" gehabt.

Aber der Standard hat das nunmal anders beschlossen.
Und ich finde sogar, dass das gut ist, denn so eine "Signaturerweiterung" würde schon im Standardfall der Polymorphie (für den ja virtual gemacht wurde) schon nicht mehr funktionieren:

struct A {
    virtual void tuWas();
};

struct B : A {
    void tuWas(Objekttyp1 hiermit);
}; 

struct C : A {
    void tuWas(Objekttyp2 hiermit);
};

// tuWas() haben ja alle As (also auch seine "Erben") gemeinsam:
void mache_was_mit_irgendeinem_A(A* a);

int main() {
   A a;
   B b;
   C c;
   mache_was_mit_irgendeinem_A(&a);
   mache_was_mit_irgendeinem_A(&b);
   mache_was_mit_irgendeinem_A(&c);
   return 0;
}

void mache_was_mit_irgendeinem_A(A* a) {
   a->tuWas(???????); // <--- was soll ich da hinschreiben ?
}

Gruß,

Simon2.

P.S.: Du hast da ein "class" mehr als nötig. In C++ ist bereits "A" ein Typ ... da braucht's kein "class" (oder "struct") mehr davor.

struct A {
    void tuWas() { tuWas_impl(); }             // polymorph
private:
    virtual void tuWas_impl();     // ggf. = 0
};

struct B : A {
    void tuWas(Objekttyp1 hiermit=Objekttyp1()) { tuWas_impl(hiermit); } // polymorph, "überschreibt" tuWas in A (technisch ist es natürlich eine Überladung)
private:
    void tuWas_impl() { tuWas(); }             // überschreibt die virtuelle Funktion aus A und forwarded an B::tuWas; ist hier "final"
    virtual void tuWas_impl(Objekttyp1)        // kontravariant erweiterte virtuelle Funktion, wird ggf. analog in abgeleiteter Klasse überschrieben
};
usw...