Erzeugt eine abgeleitet Klasse eine Funktion mit demselben Rückgabetyp und derselben Signatur wie eine Elementfunktion in der Basisklasse, aber mit einer neuen Implementierung, spricht man vom "Redefinieren" oder "Überschreiben" dieser Methode.

Verstehe ich nicht. Es reicht doch einfach wenn der Name in der abgeleitet Klasse den gleichen Namen wie eine Methode in der Basisklasse hat oder? Wenn ich in der Basisklasse die Methode

void Say() const {cout << "Hallo\n";}

habe und in der abgeleiteten Klasse

int Say(int a) {cout << "Hans geht " << a << " Meter.\n";
                return a;
               }

Ist doch nun auch "redefiniert" oder? Und sie haben nicht denselben Rückgabetyp oder etwa die selbe Signatur.
Kann mich jemand auklären? Dankeschön schon mal im Voraus.

http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=oho#Answ

void F1()
{
    cout << "F1\n";
}

int F1(int a)
{
    cout << "10\n";
}

int main()
{
    F1();
    F1(5);
    return 0;
}

Boah bin ganz verwirrt, den Link muss ich glaub noch 2-3mal durchlesen.

übernimmst du aber für die funktion in der abgeleiteten klasse name, rückgabetyp und argumentenliste der "original"-funktion, gibt es ja immernoch nur eine einzige "version" davon. wenn du also die funktion der abgeleiteten klasse aufrufst, wird (sofern du nicht explizit die implementierung der basisklasse aufrufst) immer diese implementation (aus der abgeleiteten klasse) der funktion aufgerufen.
->redifiniert

mfg,
julian

Redefinition (redefinition): Die erneute Definition einer Entität. Innerhalb der selben Übersetzungseinheit ist dies in keinem Falle zulässig. In verschiedenen Übersetzungseinheiten ist dies erlaubt für Typ- und Templatedefinitionen sowie Inlinefunktionen. Ein typedef bewirkt - trotz des Schlüsselworts - eine Deklaration und keine Definition und darf daher beliebig wiederholt werden.

Verdeckung (name hiding): Ein Name kann in einem inneren Scope oder einer abgeleiteten Klasse erneut deklariert werden und verdeckt dann die äußere Deklaration. Die durch den Namen bezeichneten Entität kann dabei jeder Kategorie angehören. Ein Sonderfall besteht, wenn ein Klassen- oder Aufzählungsname im selben Scope mit dem Namen einer Funktion, eines Objekts oder einer Aufzählungskonstante zusammentrifft. Verdeckt also eine Funktion eine andere, so bestehen keinerlei Einschränkungen hinsichtlich ihres Typs.

Überladung (overloaded declarations): Mehrere Funktionen gleichen Namens können im selben Scope existieren, wenn sie sich hinsichtlich ihrer Parameterlisten (den Objektparameter von Memberfunktionen zähle ich hier für diesen Zweck dazu) unterscheiden. Statische Klassenfunktionen können nicht mit nichtstatischen überladen werden. Weder begründen unterschiedliche Rückgabetypen oder Exceptionspezifikationen Überladbarkeit noch werden jene durch diese Bedingt.

Man kann Verdeckung als vertikale und Überladung als horizontale Vielfachheit eines Namens begreifen.

Überschreibung (override): Die Deklaration einer (implizit virtuellen) Funktion, die eine (andernfalls nicht verdeckte) virtuellen Funktion in einer Basisklasse ersetzt (ein Aufruf über eine polymorphe Basis benutzt diese Funktion). Sie tut dies dann, wenn sie in ihren Parametern mit denen der geerbten Funktion übereinstimmt (bis auf die zwingende Kovarianz des Objektparameters) und in ihrem Rückgabetyp und der Exceptionspezifikation wenigstens genauso streng ist. Die Garantien hinsichtlich Rückgabetyp und Exceptionspezifikation dürfen strenger sein, d.h. ein Zeiger oder eine Referenz auf ein Klasse darf in der Überschreibung auf eine (öffentlich) abgeleitende Klasse verweisen. Auf die Problematik von Exceptionspezifikationen will ich hier nicht eingehen. Eine vergleichbare Kontravarianz für Funktionsparameter - wie sie in einigen anderen Sprachen existiert - ist nicht möglich. Sie würde zumindest problematisch sein, wenn noch Überladung oder Mehrfachvererbung hinzukommt.

mfg,
julian

#include <iostream>
using namespace std;

class Tier
{
    public:
    Tier() {};
    ~Tier() {};
    void Speak() {cout << "TIER\n";}
};

class Hund : public Tier
{
    public:
    Hund() {};
    ~Hund() {};
    void Speak() {cout << "HUND\n";} //wird hier redefiniert, da ja schon mal in Basisklasse Tier
};

int main()
{
    Tier BigAnimal;
    Hund Bob;
    BigAnimal.Speak();
    Bob.Speak();
    return 0;
}

Aber was wäre den dann bitte das hier? Nach Definition: "Erzeugt eine abgeleitet Klasse eine Funktion mit demselben Rückgabetyp und derselben Signatur wie eine Elementfunktion in der Basisklasse, aber mit einer neuen Implementierung, spricht man vom "Redefinieren" oder "Überschreiben" dieser Methode." kann es ja nicht Redefinieren sein! Aber für mich ist das eigentlich trotzdem das gleiche.

#include <iostream>
using namespace std;

class Tier
{
    public:
    Tier() {};
    ~Tier() {};
    void Speak(int a) {cout << "TIER " << a << "\n";}
};

class Hund : public Tier
{
    public:
    Hund() {};
    ~Hund() {};
    int Speak() {cout << "HUND\n";
                 return 120;
                }
};

int main()
{
    Tier BigAnimal;
    Hund Bob;
    BigAnimal.Speak(5);
    Bob.Speak();
    return 0;
}

Dankeschön schon mal im Voraus.

mfg,
julian

#include <iostream>
using namespace std;

class Tier
{
    public:
    Tier() {};
    ~Tier() {};
    void Speak(int a) {cout << "TIER " << a << "\n";}
};

class Hund : public Tier
{
    public:
    Hund() {};
    ~Hund() {};
    int Speak() {cout << "HUND\n";
                 return 120;
                }
};

int main()
{
    Tier BigAnimal;
    Hund Bob;
    BigAnimal.Speak(5);
    Bob.Speak(10);
    return 0;
}

Compiling: C:\MinGW\Andi\ÜberschreibenÜberdeckenÜberladen.cpp
C:\MinGW\Andi\ÜberschreibenÜberdeckenÜberladen.cpp: In function int main()': C:\\MinGW\\Andi\\ÜberschreibenÜberdeckenÜberladen.cpp:27: error: no matching function for call toHund::Speak(int)'
C:\MinGW\Andi\ÜberschreibenÜberdeckenÜberladen.cpp:17: note: candidates are: int Hund::Speak()
Process terminated with status 1 (0 minutes, 0 seconds)
2 errors, 0 warnings

Dankeschön schon mal im Voraus.

Generell läuft die Suche nach der passenden Funktion in drei Schritten ab:

1. Bildung der Kandidatenmenge
2. Auswahl der Funktionen mit passender Signatur aus der Kandidatenmenge
3. Auswahl der am Besten passenden Funktion

Ausgehend vom Scope in dem der Aufruf steht, kommen alle die Funktionen in die Kandidatenmenge, die den selben Namen haben wie die aufzurufende Funktion. Existiert in dem Scope keine solche Funktion, wird der darüberliegende Scope durchsucht. Umschließende Scopes werden also nur berücksichtigt, wenn in den eingeschlossenen Scopes keine gleichnamige Funktion existiert.

Das markierte ist wichtig, d.h. er hört dann auf zu suchen und würde nie Tier::Speak(int) finden, weil er schon eine Funktion mit dem Namen Speak in Hund gefunden hat ....

So nebenbei: Man sollte nicht-virtuelle Memberfunktion nicht redefinieren.
Spiele mal was mit Zeigern und so rum dann wirst du sehen, wieso etwas sich nicht so verhält wie es sollte ( Steht in Effective C++ was dazu )
[Jaja ich verweise gerne auf das Buch ]

Edit: In Exceptional steht auch ne Menge zu Überladen/Überdecken etc ...

#include <iostream>
using namespace std;

class Tier
{
    public:
    Tier() {};
    ~Tier() {};
    void func(int a);
    int func();
};

void Tier::func(int a)
{
    cout << "INT" << endl;
}

int Tier::func()
{
    cout << "VOID" << endl;
}

class Hund : public Tier
{
    public:
    Hund() {};
    ~Hund() {};
    void func(float a);
};

void Hund::func(float a)
{
    cout << "FLOAT" << endl;
}

int main()
{
    Hund A;
    Tier &B=A;

    return 0;
}

Was macht den genau:

Tier &B=A;

?????
Das würde ja heißen: "B ist eine Referenz auf eine Tier Objekt" Ja? Aber A ist doch ein Hund Objekt! Also äh hat das was mit Polymorphie zu tun? Ist "Tier &B=A" sowas wie "Tier *B= new Hund"? Sowas kenn ich nämlich schon. Aber sowas wie "Tier &B=A;" hab ich noch nie gesehen (peinlich?). Also in meinem ganzen C++ Buch kam sowas noch nicht vor. Mhh vll.ste ich ja jetzt auch auf der Leitung. Kann mir vll. jemand auf die Sprünge helfen?
Dankeschön schon mal im Voraus.

Was macht den genau:

Tier &B=A;

?????
Das würde ja heißen: "B ist eine Referenz auf eine Tier Objekt" Ja? Aber A ist doch ein Hund Objekt! Also äh hat das was mit Polymorphie zu tun? Ist "Tier &B=A" sowas wie "Tier *B= new Hund"? Sowas kenn ich nämlich schon. Aber sowas wie "Tier &B=A;" hab ich noch nie gesehen (peinlich?). Also in meinem ganzen C++ Buch kam sowas noch nicht vor. Mhh vll.ste ich ja jetzt auch auf der Leitung. Kann mir vll. jemand auf die Sprünge helfen?
Dankeschön schon mal im Voraus.

Doch haste bestimmt schonmal gesehen

void func(const Tier& obj);
void othfunc(Tier& obj);
//...
Hund lessie, jimmy;
func(lessie);
othfunc(jimmy);

Referenzparameter !

Ist nicht das selbe wie Tier *B= new Hund sondern (fast):

Hund lessie;
Tier *obj = &lessie;

Was die Kombination von Zeiger und Referenz angeht, die ist dabei vollkommen beliebig

Hund h1; // Hund auf Stack
Hund* h2 = new Hund(); // Hund auf Heap

Tier& a = h1; // a ist Referenz auf das Tier im Hund h1
Tier* b = h2; // b ist Zeiger auf das Tier im Hund *h2

// Mischen possible:
Tier* d = &h1; // d ist Zeiger auf das Tier im Hund h1
Tier& c = *h2; // c ist Referenz auf das Tier im Hund *h2;

class A {
    public:
        virtual void func();    // #1
        void gunc();            // #2
    };

    class B : public A {
    public:
        using A::func;
        virtual void func(int); // #3
        virtual void gunc();    // #4
    };

    class C : public B {
    public:
        void func();            // #5
        void gunc(int);         // #6
        void gunc();            // #7
    };

    int main()
    {
        C c;
        A& rac = c;
        B& rbc = c;
        rac.func();
        rac.func(2);
        rac.gunc();
        rac.gunc(2);

        rbc.func();
        rbc.func(2);
        rbc.gunc();
        rbc.gunc(2);

        c.func();
        c.B::func(2);
        c.gunc();
        c.gunc(2);

        B b;
        A& rab = b;
        rab.func();
        rab.func(2);
        rab.gunc();
        rab.gunc(2);

        b.func();
        b.func(2);
        b.gunc();
        b.gunc(2);
    }

In Zeile 9 steht was mit "using A::func;"! (also das kam echt nicht in meinem Buch vor, using)
Mh ich glaube zwar zu wissen was es bedeutet. Heißt das in etwa sowas wie "schreibe hier in Klasse B nochmal die gleiche Methode hin wie aus Klass A" das da der Code so übernommen wird? Sowas wie ein Makro der Compiler schreibt einfach den Code hin bzw. übernimmt dann die selbe Methode von Klasse A mit Deklaration + Definition für B??? Nääää oder?
Kann mir das jemand erklären? Wäre sichere, als das ich mir das irgendwas zusammenreime Dankeschön schon mal im Voraus.

PS: Ich bin schon lernfähig, nicht das sich jemand denkt der frägt bei jedem "sch***dreck" gleich im Forum. Aber ich bin mir halt echt nicht so ganz sicher was das heißt. In diesem Sinne, hoffentlich fühlt sich keiner gestört.

#include <iostream>
using namespace std;

class Tier
{
    public:
    Tier() {};
    ~Tier() {};
    void Speak(int a) {cout << "TIER " << a << "\n";}
};

class Hund : public Tier
{
    public:
    Hund() {};
    ~Hund() {};
    int Speak() {cout << "HUND\n";
                 return 120;
                }
};

int main()
{
    Tier BigAnimal;
    Hund Bob;
    BigAnimal.Speak(5);
    Bob.Speak(10);
};

wenn du jetzt Bob.Speak(10) aufrufst, dann gab es zuvor eine Fehlermeldung weil keine Funktion bekannt war die int als Parameter hat UND gleichzeitig eine Memberfunktion von Hund ist. Jetzt kann die Methode Speak() der Basisklasse aber auch bei Hund verwendet werden.

#include <iostream>
using namespace std;

class Tier
{
    public:
    Tier() {};
    ~Tier() {};
    void Speak(int a) {cout << "TIER " << a << "\n";}
};

class Hund : public Tier
{
    public:
    Hund() {};
    ~Hund() {};
    using Tier::Speak;
    int Speak() {cout << "HUND\n";
                 return 120;
                }
};

int main()
{
    Tier BigAnimal;
    Hund Bob;
    BigAnimal.Speak(5);
    Bob.Speak(10);
    return 0;
}