c++ - para - ¿Por qué no puede funcionar un miembro protegido de llamada derivada en este código?

codigo en c para derivar un polinomio

Question

#include <iostream>

class Base
{  
protected:
    void somethingProtected()
    {
        std::cout << "lala" << std::endl;
    }
};

class Derived : public Base
{
public:
    void somethingDerived()
    {
        Base b;
        b.somethingProtected();    // This does not compile
        somethingProtected();      // But this is fine
    }
};

int main()
{
    Derived d;
    d.somethingDerived();
    return 0;
}

Pensé que tal vez solo los miembros protegidos de this pueden ser utilizados y los miembros protegidos de otras instancias son inalcanzables.

Pero:

class Derived : public Base
{
public:

    void somethingDerived(Derived& d)
    {
        d.somethingProtected();  // This compiles even though d is
                                 // potentially a different instance
    }

    void somethingDerived(Base& b)
    {
        b.somethingProtected();  // This does not
    }
};

Me siento un poco mareado por esto, ya que he estado programando en C ++ durante un tiempo, pero no pude encontrar ninguna explicación para este comportamiento.

EDITAR:

No importa si es la misma o una instancia diferente:

int main()
{
    Derived d1, d2;          // Two different instances
    d1.somethingDerived(d2); // This compiles fine
    d1.somethingDerived(d1); // This compiles fine
    return 0;
}

EDIT2:

Parece que cuando se trata de derechos de acceso, no importa en absoluto qué instancia de una clase se está utilizando:

class Base
{
public:
    void something(Base& b)  // Another instance
    {
        ++b.a;               // But can enter private members
    }

private:
    int a;
};

Answer 1

Aunque el control de acceso en C ++ funciona en base a clases (en lugar de hacerlo por instancia), el especificador de acceso protected tiene algunas peculiaridades.

La especificación del lenguaje quiere garantizar que está accediendo a un miembro protegido de algún subobjeto base que pertenece a la clase derivada. Se supone que no puede acceder a los miembros protegidos de algunos objetos independientes no relacionados de tipo base. En particular, no puede acceder a miembros protegidos de objetos independientes de tipo base. Solo se le permite acceder a miembros protegidos de objetos base que están incrustados en objetos derivados como subobjetos base.

Por este motivo, debe acceder a los miembros protegidos a través de la sintaxis pointer->member syntax, reference.member o object.member , donde el puntero / referencia / objeto se refiere a la clase derivada .

Esto significa que en su ejemplo, el miembro protegido somethingProtected() no es accesible a través Base objetos Base , punteros Base * o Base & referencias, pero se puede acceder a través de objetos Derived * , punteros Derived * y Derived & referencias. Su acceso simple somethingProtected() protegido somethingProtected() está permitido, ya que es solo una abreviatura de this->somethingProtected() donde this es de tipo Derived * .

b.somethingProtected() infringe los requisitos anteriores.

Tenga en cuenta que de acuerdo con las reglas anteriores en

void Derived::somethingDerived()
{
    Base *b = this;
    b->somethingProtected();    // ERROR
    this->somethingProtected(); // OK
}

la primera llamada también fallará mientras que la segunda compilará, aunque ambas intenten acceder a la misma entidad.

Answer 2

Creo que tienes cierta confusión sobre cómo acceder a los miembros de la clase base. Es solo así:

class Derived : public Base
void drivedMethod() {
    Base::baseMethod();
}

en su ejemplo, intenta acceder a un miembro protegido de otra instancia.

una instancia Derivada tendrá acceso a sus propios miembros protegidos, pero no a otros miembros protegidos de instancia de clase, esto es por diseño.

De hecho, el acceso a los miembros protegidos de otra clase, desde otros miembros de la instancia o desde la función principal, de hecho ambos están bajo acceso público ...

http://www.cplusplus.com/doc/tutorial/inheritance/ (busque la tabla de especificaciones de acceso para ver los diferentes niveles)

Ambos ejemplos demuestran lo mismo, por ejemplo:

void somethingDerived(Base& b)
    {
        b.somethingProtected();  // This does not

aquí su clase derivada obtiene b como parámetro, por lo tanto, está obteniendo otra instancia de base, y como b.somethingProtected no es público, no cumplirá.

esto cumplirá:

void somethingDerived()
{
   Base::somethingDerived();

su segundo ejemplo cumple bien porque está accediendo a un método público en otra clase d

>  void somethingDerived(Base& b)
>     {
>         b.somethingProtected();  // This does not
>     }

Answer 3

La clase Derived solo puede acceder al miembro base protegido en objetos Derived . No puede acceder al miembro en objetos que no son (necesariamente) Objetos Derived . En los casos que fallan, está tratando de acceder al miembro a través de una Base & , y dado que esto podría referirse a un objeto que no es Derived , no se puede realizar el acceso.

Answer 4

Lo que has hecho es ilegal en C ++. Un objeto protegido no puede acceder a un miembro protegido. Solo las funciones miembro pueden acceder a miembros protegidos. protected miembros protected se comportan igual que los miembros privados, excepto cuando son heredados por una clase derivada. Considere el programa que se proporciona a continuación para comprender la diferencia entre los miembros privados, públicos y protegidos.

class Base
{
    private:
    void somethingPrivate()
    {
        std::cout << "sasa" << std::endl;
    }
    public:
    void somethingPublic()
    {
        std::cout << "haha" << std::endl;
    }
    protected:
    void somethingProtected()
    {
        std::cout << "lala" << std::endl;
    }
};

class Derived : public Base
{
public:
    void somethingDerived()
    {
       Base b;
       b.somethingPublic();   // Works fine.
       somethingProtected();  // This is also fine because accessed by member function.
       //b.somethingProtected();  // Error. Called using object b.
       //somethingPrivate();      // Error. The function is not inherited by Derived.
    }
};