C++ - Přetížení vs Převažující v Dědictví

V C++, nějaké metody v odvozené třídě pouze přepíše metodu v základní třídě, pokud jejich prohlášení zápas (já říkám "match", ale nevím, formální termín pro to). To znamená, že všechny argumenty musí mít stejný typ a const kvalifikace this musí být stejné. Pokud tam nic nesouladu, metodu v odvozené třídy skryje všechny metody se stejným jménem, namísto přepsání. To je to, co "CHYBA" v obrázku se snaží říct. Tak // overrides v komentáři v tom, že obraz je nesprávné a zavádějící.

Ano, mnoho C++ učitelé vlastně nechápeš ty poněkud obskurní detaily.

BTW navíc, pokud chcete přepsat metodu v základní třídě by měla být virtual; jinak, polymorfismus nebude fungovat. Kdyby to bylo ne virtual, můžeme také říci, že odvozené třídy metody se skrývá základní metody třídy. Tady, nicméně, ta část o skrývání nemá téměř žádný význam; co tento termín opravdu chce vyjádřit, že nejsi převažující.

Kromě toho, přetížení je, jak jste si všimli, přítomnost několik metod se stejným názvem, ale různé podpisy. Všechny by měly být přítomny v odvozené třídě, aby být užitečné - pokud odvozená třída má pouze jednu metodu fa1a další fa1 jsou v základu, budou skryté. Nicméně, tam je syntaktický cukr, který "kopie" všechny fa1 ze základny na odvozené, zakázání všechny, které skrývá sémantika:

class A
{
public:
    void fa1();
    void fa1(int);
};

class B: public A
{
public:
    using A::fa1;
    void fa1(int, int);
};

...
B b;
b.fa1(); // calls A::fa1()
b.fa1(4); // calls A::fa1(int)
b.fa1(4, 8); // calls B::fa1(int, int)

Část o skrývání je jen zřídka, pokud vůbec, užitečné. Při přepsání, měl bys to říct, aby to kompilátor - použít override klíčové slovo pro to. Kompilátor pak zkontrolujte, zda váš kód funguje, jak jste zamýšleli.

class A
{
public:
    virtual void fa1(int) {}
    void fa2(int) {}
};

class B: public A
{
public:
    void fa1(int) override {} // OK
    void fa1() override {} // ERROR: doesn't really override - different signature
    void fa2(int) override {} // ERROR: doesn't really override - not virtual in base
};

ia1 ne přetížení. První nemůžete přetížení proměnných. Tak ia1 je rozhodně ovládání. A to je také nebezpečná věc. V mé společnosti, náš kódování norem zakázat přepsání názvy proměnných v každé situaci. To vede jen ke zmatku.

fa1 i když-vypadá to jako přetížení. Základní třída fa1() trvá žádné argumenty, ale podtřídy verze má plovák.