Come accedere al metodo protetto nella classe base dalla classe derivata?

Question

Ecco un esempio di codice che mi infastidisce:

class Base { 
    protected: 
    virtual void foo() = 0; 
}; 

class Derived : public Base { 
    private: 
    Base *b; /* Initialized by constructor, not shown here 
       Intended to store a pointer on an instance of any derived class of Base */ 

    protected: 
    virtual void foo() { /* Some implementation */ }; 
    virtual void foo2() { 
     this->b->foo(); /* Compilator sets an error: 'virtual void Base::foo() is protected' */ 
    } 
}; 

Come si accede alla funzione overrided protetta?

Grazie per il vostro aiuto. : o)

Answer 1

I membri protetti in una classe base sono accessibili solo dall'oggetto corrente.
Pertanto, è possibile chiamare this->foo(), ma non è consentito chiamare this->b->foo(). Ciò è indipendente dal fatto che Derived fornisca o meno un'implementazione per foo.

La ragione di questa limitazione è che sarebbe altrimenti molto semplice aggirare l'accesso protetto. Devi solo creare una classe come Derived e improvvisamente hai accesso anche a parti di altre classi (come OtherDerived) che dovevano essere inaccessibili agli estranei.

Answer 2

Normalmente, lo si farebbe utilizzando , che si riferisce alla classe base dell'istanza corrente.

Tuttavia, se il codice ha bisogno di farlo nel modo in cui si sta provando e non è consentito, allora è necessario rendere pubblico foo() o rendere Derived un amico di Base.

Answer 3

Si richiamano esplicitamente le funzioni di base con l'operatore di ambito (Base :: pippo()). Ma in questo caso, la classe Base non definisce foo (è puro virtuale), quindi non c'è in realtà alcuna funzione da eseguire quando si dice this->b->foo(); poiché b è un puntatore a Base e non derivato.

Answer 4

Come si accede alla funzione protetta annullata?

--- da dove?

È possibile accedere a un membro protetto solo tramite ereditarietà (a parte i metodi della stessa classe). Supponiamo ad esempio di avere un class Derived1 che eredita da Derived, quindi gli oggetti di Derived1 possono chiamare foo().

MODIFICA: MSDN article su identificatore di accesso protetto.

Answer 5

È un po 'fragile, ma con le classi che hai definito qui, non funzionerà?

virtual void foo2() { 
    reinterpret_cast<Derived *>(this->b)->foo(); 
} 

I punti reinterpret_cast al VTABLE per l'oggetto di base, e chiede attraverso questo membri di accesso.

Answer 6

Una soluzione sarebbe dichiarare una funzione protetta statica in Base che reindirizza la chiamata alla funzione privata/protetta (foo nell'esempio).

consente di dire:

class Base { 
protected: 
    static void call_foo(Base* base) { base->foo(); } 
private: 
    virtual void foo() = 0; 
}; 

class Derived : public Base { 
private: 
    Base* b; 
protected: 
    virtual void foo(){/* Some implementation */}; 
    virtual void foo2() 
    { 
     // b->foo(); // doesn't work 
     call_foo(b); // works 
    } 
}; 

In questo modo, non si rompono incapsulamento perché il progettista di Base può fare una scelta esplicita per consentire tutte le classi derivate di chiamare foo a vicenda, evitando di mettere foo nell'interfaccia pubblica o esplicitamente trasformando tutte le possibili sottoclassi di Base in amici.

Inoltre, questo metodo funziona indipendentemente dal fatto che foo sia virtuale o meno, o che sia privato o protetto.

Here è un collegamento a una versione in esecuzione del codice sopra e here un'altra versione della stessa idea con un po 'più di logica aziendale.