Jak zapobiegać wezwanie do wdrożenia podstawowej metody

Question

powiedzmy, że mamy następującą hierarchię:

class Abstract 
{ 
public: 
    virtual void foo() = 0; 
}; 

class Base : public Abstract 
{ 
public: 
    virtual void foo() override; //provides base implementation 
}; 

class Derived : public Base 
{ 
public: 
    virtual void foo() override; //provides derived implementation 
}; 

Jeśli Base::foo() kiedykolwiek nazywa na obiekcie Derived że obiekt będzie utratę synchronizacji, a jego dane zostaną uszkodzone. Dziedziczy on strukturę danych i jej manipulację, ale musi wykonać dodatkowe operacje, dlatego wywołanie tylko tych Base::foo() spowoduje pominięcie tych dodatkowych operacji, w wyniku czego stan Derived zostanie uszkodzony.

Dlatego chciałbym uniknąć bezpośredniego połączenia z Base realizacji foo więc to:

Derived d; 
d.Base::foo(); 

idealnie, powinien dać mi błąd czasu kompilacji niektórych rodzajów. Lub nie rób nic lub w inny sposób można temu zapobiec.

Jednak może to być ja naruszające zasady polimorfizmu i powinno zamiast użyć kompozycję ale to wymagałoby dużo dodatkowego typowania ...

Answer 1

Jak o template method pattern:

class Abstract 
{ 
public: 
    void foo() { foo_impl(); } 
private: 
    virtual void foo_impl() = 0; 
}; 

class Base : public Abstract 
{ 
private: 
    virtual void foo_impl() override; //provides base implementation 
}; 

class Derived : public Base 
{ 
private: 
    virtual void foo_impl() override; //provides derived implementation 
}; 

następnie

void test(Abstract& obj) { 
    obj.foo(); // the correct foo_impl() will be invoked 
} 
Derived d; 
test(d); // impossible to call the foo_impl() of Base 

Answer 2

Można zrobić wszystkie metody foo() nie- public, a następnie mieć non - virtual funkcja w klasie Abstract, która po prostu wywołuje foo.

Answer 3

Można zwiedzić template method pattern. Pozwala to na większą kontrolę nad realizacją zaangażowanych metod.

class Abstract 
{ 
public: 
    virtual void foo() = 0; 
}; 

class Base : public Abstract 
{ 
protected: 
    virtual void foo_impl() = 0; 
public: 
    //provides base implementation and calls foo_impl() 
    virtual void foo() final override { /*...*/ foo_impl(); } 
}; 

class Derived : public Base 
{ 
protected: 
    virtual void foo_impl() override; //provides derived implementation 
}; 

Wzór jest widoczny w bibliotece iostreams z sync() i pubsync() metod.

Aby uniemożliwić bezpośrednie połączenia i zachować spójny stan, musisz uzyskać final implementację metody foo we właściwym miejscu w stosie. Jeśli chcesz zabronić bezpośredniego połączenia z góry hierarchii, możesz przenieść metody _impl.

Zobacz także interfejs inny niż wirtualny, the NVI pattern.

---

Należy pamiętać również, że metody nadrzędne nie muszą mieć ten sam specyfikator dostępu jako klasy Abstract. Można również po prostu tworzyć metody w pochodnych klasach private lub protected;

class Abstract 
{ 
public: 
    virtual void foo() = 0; 
}; 

class Base : public Abstract 
{ 
    virtual void foo() override; //provides base implementation 
}; 

class Derived : public Base 
{ 
    virtual void foo() override; //provides derived implementation 
}; 

Uwaga: jeżeli nie ma inaczej, zmieniając specyfikator dostępu można uznać za złe design - tak w zasadzie, jeśli nie zmieni specyfikator dostępu, nie powinien powinien być dobry powód, aby to zrobić.