Come prevenire chiamata alla implementazione base di un metodo

Question

Diciamo che abbiamo seguente gerarchia:

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 
}; 

Se Base::foo() viene mai chiamato sull'oggetto Derived che oggetto si desincronizzazione ed i suoi dati saranno danneggiati. Assorbe la struttura dei dati di Base e la sua manipolazione, ma deve eseguire operazioni aggiuntive, quindi chiamare solo il ometterà queste operazioni extra e, di conseguenza, lo stato di Derived sarà danneggiato.

Perciò vorrei evitare che la chiamata diretta di Base realizzazione di foo quindi questo:

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

idealmente, dovrebbe darmi un errore di tempo di compilazione di alcune specie. O non fare nulla o altrimenti essere prevenuto.

Tuttavia potrebbe essere che sto violando le regole polimorfismo e dovrei usare la composizione, invece, ma che richiederebbe un sacco di battitura a macchina in più ...

Answer 1

Come su 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 
}; 

poi

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

È possibile effettuare tutte le foo() metodi non public, quindi hanno un non - Funzione virtual nella classe Abstract che chiama semplicemente foo.

Answer 3

è possibile esplorare la template method pattern. Consente un maggiore controllo dell'esecuzione dei metodi coinvolti.

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 
}; 

Il modello è visto nella biblioteca iostreams con sync() e pubsync() metodi.

Per impedire le chiamate dirette e mantenere lo stato coerente, è necessario ottenere l'implementazione final del metodo foo nella posizione corretta nello stack. Se l'intenzione è quella di vietare la chiamata diretta dalla parte superiore della gerarchia, è possibile spostare i metodi _impl.

Vedere anche l'interfaccia non virtuale, the NVI pattern.

---

Tenete a mente pure che i metodi imperative non devono avere lo stesso specificatore di accesso della classe Abstract. Si potrebbero anche solo eseguire i metodi nelle classi derivate private o 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 
}; 

Nota: se non diversamente previsto, cambiando la specificatore di accesso potrebbe essere considerato cattivo design - in modo sostanzialmente se si fa cambiare lo specificatore di accesso, ci dovrebbe dovrebbe essere un buon motivo per farlo.