Impossibile accedere membro protetto della classe base in classe derivata

Question

Ho il seguente codice:

struct A { 
protected: 
    A() {} 

    A* a; 
}; 

struct B : A { 
protected: 
    B() { b.a = &b; } 

    A b; 
}; 

E stranamente non compilazione. Il colpevole è il compito b.a = &b;: sia GCC che clang si lamentano che A() è protetto, il che non dovrebbe essere un problema perché B eredita A. Quale angolo oscuro dello standard sono entrato?

Answer 1

Il significato di protected è che il tipo derivato avrà accesso a tale membro di propria base e non di qualsiasi oggetto casuale ^*. Nel tuo caso, si cura cercando di modificare membro b s', che è al di fuori del vostro controllo (ad esempio è possibile impostare this->a, ma non b.a)

c'è un trucco per arrivare a questo lavoro, se siete interessati, ma un la soluzione migliore sarebbe quella di rifattorizzare il codice e non dipendere dagli hack. Si potrebbe, ad esempio, fornire un costruttore in A che prende un A* come argomento (questo costruttore dovrebbe essere pubblico) e poi inizializzare nella lista di inizializzazione dei B:

A::A(A* p) : a(p) {} 
B::B() : b(&b) {} 

---

^*protected sovvenzioni si accede al membro di base in qualsiasi istanza del proprio tipo o derivata dal proprio tipo.

Answer 2

Tutti i compilatori che ho testato si sono lamentati di diverse cose, e in particolare il costruttore protetto sarebbe stato un problema anche se la dichiarazione di assegnazione fosse stata rimossa.

Non si accede ai membri di protected di qualsiasi istanza di un tipo derivato. Questo problema è stato chiarito negli esempi di 11.4p1.

class B { 
protected: 
    int i; 
    static int j; 
}; 

class D1 : public B { 
}; 

class D2 : public B { 
    void mem(B*, D1*); 
}; 

void D2::mem(B* pb, D1* p1) { 
    pb->i = 1; // ill-formed 
    p1->i = 2; // ill-formed 
    // ... 
} 

Answer 3

Ci sono in realtà due problemi separati qui.

Il primo è che la linea non esegue solo un compito, ma tenta di inizializzare la classe base (che funziona bene) e il membro b. Per creare il membro b è necessario costruirlo e come membro ha bisogno di public accesso a un costruttore, che non ha.

Quindi l'assegnazione non è in grado di accedere a un membro non pubblico di b perché di nuovo, non è di tipo B ma digitare A invece.

Ricordate che protected significa che è possibile accedere a parti del Aattraverso un B oggetto (o bambino) solo.

In questo caso, diteci il vostro vero problema e possiamo cercare di aiutarlo a risolverlo. Ereditare e comporre dallo stesso tipo è un odore di design.

Answer 4

Sembra una grande limitazione del linguaggio C++.Come si risolve il problema in questo modo:

class Node 
{ 
public: 
void Save(); 
protected: 
virtual void SaveState(int type) = 0; 
}; 

class BinaryNode : public Node 
{ 
protected: 
Node *left; 
Node *right; 

virtual void SaveState(int type) override 
{ 
    left->SaveState(type); 
    right->SaveState(type); 
} 
}; 

In questo esempio io non voglio fare il metodo SaveState visibile Node gerarchia di fuori. Solo il metodo Save dovrebbe essere public.