Impedisci alla classe ereditaria di ignorare la funzione virtuale della classe base

Question

La situazione è simile a questa.

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

class MyClass : Interface 
{ 
public: 
    virtual void bar() = 0; 
private: 
    void foo() 
    { 
     //Some private work and checks. 
     bar(); 
    }; 
} 

voglio che il mio utente creerà una classe che eredita da MyClass, e si dovrà attuare lì bar().
Ma come posso fare in modo che non vengano ignorati foo()? perché è importante per me usare il mio foo().

Answer 1

In C++ 11 è possibile contrassegnare il metodo come final per impedire che venga sovrascritto:

class MyClass : Interface 
{ 
public: 
    virtual void bar() = 0; 
private: 
    void foo() final 
    { 
     //Some private work and checks. 
     bar(); 
    }; 
} 

Answer 2

Come per altra risposta, è possibile utilizzare final parola chiave in C++ 11 (tale struttura è simile alla parola chiave Java final).

Per il codice C++ 03, è possibile utilizzare CRTP meccanismo (a condizione se si può cambiare la definizione di Interface)

template<typename Derived> 
class Interface 
{ 
public: 
    void foo() // not 'virtual' 
    { 
    static_cast<Derived*>(this)->foo(); 
    } 
} 

class MyClass : public Interface<MyClass> 
{ 
public: 
    virtual void bar() = 0; 
private: 
    void foo() 
    { 
     //Some private work and checks. 
     bar(); 
    }; 
} 

Così ora avete rimuovere il virtual ness del foo() e il legame che accadrà al momento della compilazione. Ricorda che CRTP ha una sua limitazione, quindi se utilizzarlo o meno dipende da te.