c++ - Diferencia entre herencia privada, pública y protegida.
inheritance encapsulation (15)
¿Cuál es la diferencia entre public
herencia public
, private
y protected
en C ++? Todas las preguntas que he encontrado en SO tratan casos específicos.
Privado:
Solo los miembros de esa clase base pueden acceder a los miembros privados de una clase base.
Público:
Se puede acceder a los miembros públicos de una clase base por los miembros de esa clase base, los miembros de su clase derivada y los miembros que están fuera de la clase base y la clase derivada.
Protegido:
Los miembros de una clase base pueden acceder a los miembros protegidos de la clase base, así como a los miembros de su clase derivada.
En breve:
privado : base
protegido : base + derivado
público : base + derivado + cualquier otro miembro
Encontré una respuesta fácil y también pensé en publicarla para mi futura referencia.
Es de los enlaces http://www.learncpp.com/cpp-tutorial/115-inheritance-and-access-specifiers/
class Base
{
public:
int m_nPublic; // can be accessed by anybody
private:
int m_nPrivate; // can only be accessed by Base member functions (but not derived classes)
protected:
int m_nProtected; // can be accessed by Base member functions, or derived classes.
};
class Derived: public Base
{
public:
Derived()
{
// Derived''s access to Base members is not influenced by the type of inheritance used,
// so the following is always true:
m_nPublic = 1; // allowed: can access public base members from derived class
m_nPrivate = 2; // not allowed: can not access private base members from derived class
m_nProtected = 3; // allowed: can access protected base members from derived class
}
};
int main()
{
Base cBase;
cBase.m_nPublic = 1; // allowed: can access public members from outside class
cBase.m_nPrivate = 2; // not allowed: can not access private members from outside class
cBase.m_nProtected = 3; // not allowed: can not access protected members from outside class
}
Es esencialmente la protección de acceso del público y los miembros protegidos de la clase base en la clase derivada. Con la herencia pública, la clase derivada puede ver miembros públicos y protegidos de la base. Con herencia privada, no puede. Con protegido, la clase derivada y cualquier clase derivada de eso pueden verse.
Estas tres palabras clave también se utilizan en un contexto completamente diferente para especificar el modelo de herencia de visibilidad .
Esta tabla recopila todas las combinaciones posibles de la declaración de componentes y el modelo de herencia que presenta el acceso resultante a los componentes cuando la subclase está completamente definida.
La tabla anterior se interpreta de la siguiente manera (eche un vistazo a la primera fila):
Si un componente se declara público y su clase se hereda como pública, el acceso resultante es público .
Un ejemplo:
class Super {
public: int p;
private: int q;
protected: int r;
};
class Sub : private Super {};
class Subsub : public Sub {};
El acceso resultante para las variables p
, q
, r
en la clase Subsub es ninguno .
Otro ejemplo:
class Super {
private: int x;
protected: int y;
public: int z;
};
class Sub : protected Super {};
El acceso resultante para las variables y
, z
en la clase Sub está protegido y para la variable x
es ninguno .
Un ejemplo más detallado:
class Super {
private:
int storage;
public:
void put(int val) { storage = val; }
int get(void) { return storage; }
};
int main(void) {
Super object;
object.put(100);
object.put(object.get());
cout << object.get() << endl;
return 0;
}
Ahora vamos a definir una subclase:
class Sub : Super { };
int main(void) {
Sub object;
object.put(100);
object.put(object.get());
cout << object.get() << endl;
return 0;
}
La clase definida llamada Sub, que es una subclase de la clase llamada Super
o esa clase Sub
, se deriva de la clase Super
. La Sub
no introduce nuevas variables ni nuevas funciones. ¿Significa que cualquier objeto de la clase Sub
hereda todos los rasgos después de que la clase Super
sea de hecho una copia de los objetos de una clase Super
?
No No lo hace
Si compilamos el siguiente código, no obtendremos más que errores de compilación que put
get
métodos de put
y get
son inaccesibles. ¿Por qué?
Cuando omitimos el especificador de visibilidad, el compilador asume que vamos a aplicar la llamada herencia privada . Esto significa que todos los componentes de superclase públicos se convierten en acceso privado, los componentes de superclase privados no serán accesibles en absoluto. En consecuencia, significa que no se le permite utilizar este último dentro de la subclase.
Tenemos que informar al compilador que queremos preservar la política de acceso utilizada anteriormente.
class Sub : public Super { };
No se deje engañar : no significa que los componentes privados de la Super clase (como la variable de almacenamiento) se conviertan en públicos de una manera un tanto mágica. Los componentes privados seguirán siendo privados , los públicos seguirán siendo públicos .
Los objetos de la clase Sub
pueden hacer "casi" las mismas cosas que sus hermanos mayores creados a partir de la clase Super
. "Casi" porque el hecho de ser una subclase también significa que la clase perdió el acceso a los componentes privados de la superclase . No podemos escribir una función miembro de la clase Sub
que podría manipular directamente la variable de almacenamiento.
Esta es una restricción muy seria. ¿Hay algún trabajo alrededor?
Si
El tercer nivel de acceso se llama protegido . La palabra clave protegida significa que el componente marcado con él se comporta como uno público cuando es usado por cualquiera de las subclases y se parece privado al resto del mundo . - Esto es cierto solo para las clases de herencia pública (como la clase Super en nuestro ejemplo) -
class Super {
protected:
int storage;
public:
void put(int val) { storage = val; }
int get(void) { return storage; }
};
class Sub : public Super {
public:
void print(void) {cout << "storage = " << storage;}
};
int main(void) {
Sub object;
object.put(100);
object.put(object.get() + 1);
object.print();
return 0;
}
Como se ve en el código de ejemplo, tenemos una nueva funcionalidad para la clase Sub
y hace una cosa importante: accede a la variable de almacenamiento desde la clase Super .
No sería posible si la variable fuera declarada como privada. En el ámbito de la función principal, la variable permanece oculta de todos modos, así que si escribe algo como:
object.storage = 0;
El compilador le informará que es un error: ''int Super::storage'' is protected
.
Finalmente, el último programa producirá el siguiente resultado:
storage = 101
La herencia pública modela una relación IS-A. Con
class B {};
class D : public B {};
cada D
es una B
La herencia privada modela una relación de USO IMPLEMENTADO-IS (o como se llame). Con
class B {};
class D : private B {};
una D
no es una B
, pero cada D
usa su B
en su implementación. La herencia privada siempre se puede eliminar utilizando la contención en su lugar:
class B {};
class D {
private:
B b_;
};
Esta D
, también, puede implementarse usando B
, en este caso usando su b_
. La contención es un acoplamiento menos apretado entre los tipos que la herencia, por lo que en general debería preferirse. A veces, usar la contención en lugar de la herencia privada no es tan conveniente como la herencia privada. A menudo eso es una excusa poco convincente para ser perezoso.
No creo que nadie sepa qué modelos de herencia protected
. Al menos no he visto ninguna explicación convincente todavía.
Limitar la visibilidad de la herencia hará que el código no pueda ver que alguna clase hereda otra clase: las conversiones implícitas de la derivada a la base no funcionarán, y static_cast
de la base a la derivada tampoco funcionará.
Solo los miembros / amigos de una clase pueden ver la herencia privada, y solo los miembros / amigos y las clases derivadas pueden ver la herencia protegida.
herencia pública
La herencia IS-A. Un botón es una ventana, y en cualquier lugar donde se necesite una ventana, también se puede pasar un botón.
class button : public window { };
herencia protegida
Protegido implementado en términos de. Rara vez útil. Utilizado en
boost::compressed_pair
para derivar de clases vacías y ahorrar memoria usando la optimización de clase base vacía (el ejemplo a continuación no usa una plantilla para mantenerse en el punto):struct empty_pair_impl : protected empty_class_1 { non_empty_class_2 second; }; struct pair : private empty_pair_impl { non_empty_class_2 &second() { return this->second; } empty_class_1 &first() { return *this; // notice we return *this! } };
herencia privada
Implementado en términos de El uso de la clase base es solo para implementar la clase derivada. Útil con rasgos y si el tamaño importa (los rasgos vacíos que solo contienen funciones harán uso de la optimización de clase base vacía). Sin embargo, a menudo la contención es la mejor solución. El tamaño de las cadenas es crítico, por lo que es un uso frecuente aquí
template<typename StorageModel> struct string : private StorageModel { public: void realloc() { // uses inherited function StorageModel::realloc(); } };
miembro público
Agregar
class pair { public: First first; Second second; };
Accesorios
class window { public: int getWidth() const; };
miembro protegido
Proporcionar acceso mejorado para las clases derivadas
class stack { protected: vector<element> c; }; class window { protected: void registerClass(window_descriptor w); };
miembro privado
Mantener detalles de implementación
class window { private: int width; };
Tenga en cuenta que los lanzamientos de estilo C intencionalmente permiten lanzar una clase derivada a una clase base protegida o privada de una manera definida y segura, y lanzar en la otra dirección también. Esto debe evitarse a toda costa, ya que puede hacer que el código dependa de los detalles de la implementación, pero si es necesario, puede hacer uso de esta técnica.
Para responder a esa pregunta, me gustaría describir los accesores de los miembros primero con mis propias palabras. Si ya lo sabe, pase al encabezado "siguiente:".
Hay tres accesores que conozco: public
, protected
y private
.
Dejar:
class Base {
public:
int publicMember;
protected:
int protectedMember;
private:
int privateMember;
};
- Todo lo que es consciente de
Base
también es consciente de queBase
contienepublicMember
. - Solo los niños (y sus hijos) son conscientes de que la
Base
contiene unBase
protectedMember
. - Nadie más que
Base
conoce aprivateMember
.
Por "es consciente de", me refiero a "reconocer la existencia de, y así poder acceder".
siguiente:
Lo mismo ocurre con la herencia pública, privada y protegida. Consideremos una clase Base
y una clase Child
que se hereda de la Base
.
- Si la herencia es
public
, todo lo que tiene conocimiento deBase
yChild
también es consciente de queChild
hereda deBase
. - Si la herencia está
protected
, solo elChild
y sus hijos son conscientes de que heredan de laBase
. - Si la herencia es
private
, nadie más queChild
es consciente de la herencia.
Resumen:
- Privado: nadie puede verlo excepto dentro de la clase.
- Protegido: Privado + clases derivadas pueden verlo
- Público: el mundo puede verlo.
Al heredar, puede (en algunos idiomas) cambiar el tipo de protección de un miembro de datos en cierta dirección, por ejemplo, de protegido a público.
Se puede acceder a los miembros de datos protegidos por cualquier clase que herede de su clase. Los miembros de datos privados, sin embargo, no pueden. Digamos que tenemos lo siguiente:
class MyClass {
private:
int myPrivateMember; // lol
protected:
int myProtectedMember;
};
Desde su extensión a esta clase, la referencia a this.myPrivateMember
no funcionará. Sin embargo, this.myProtectedMember
hará. El valor aún está encapsulado, por lo que si tenemos una instanciación de esta clase llamada myObj
, myObj.myProtectedMember
no funcionará, por lo que es similar en función a un miembro de datos privados.
Si hereda públicamente de otra clase, todo el mundo sabe que está heredando y cualquiera puede usarlo de forma polimórfica a través de un indicador de clase base.
Si heredas de forma protegida, solo tus clases de niños podrán usarte polimorfamente.
Si hereda de forma privada, solo usted podrá ejecutar métodos de clase padre.
Que básicamente simboliza el conocimiento que el resto de las clases tienen sobre su relación con la clase de sus padres
Tiene que ver con cómo se exponen los miembros públicos de la clase base de la clase derivada.
- público -> los miembros públicos de la clase base serán públicos (generalmente el valor predeterminado)
- protegido -> los miembros públicos de la clase base serán protegidos
- privado -> los miembros públicos de la clase base serán privados
Como señala litb, la herencia pública es una herencia tradicional que se verá en la mayoría de los lenguajes de programación. Es decir, modela una relación "IS-A". La herencia privada, algo que AFAIK es peculiar de C ++, es una relación "IMPLEMENTADA EN TÉRMINOS DE". Es decir, desea utilizar la interfaz pública en la clase derivada, pero no desea que el usuario de la clase derivada tenga acceso a esa interfaz. Muchos argumentan que, en este caso, debe agregar la clase base, es decir, en lugar de tener la clase base como una base privada, hacer un miembro de derivado para reutilizar la funcionalidad de la clase base.
1) Herencia pública :
a. Los miembros privados de la clase Base no son accesibles en la clase Derivada.
segundo. Los miembros protegidos de la clase Base permanecen protegidos en la clase Derivada.
do. Los miembros públicos de la clase base siguen siendo públicos en la clase derivada.
Por lo tanto, otras clases pueden usar miembros públicos de la clase Base a través del objeto Clase derivada.
2) Herencia protegida :
a. Los miembros privados de la clase Base no son accesibles en la clase Derivada.
segundo. Los miembros protegidos de la clase Base permanecen protegidos en la clase Derivada.
do. Los miembros públicos de la clase Base también se convierten en miembros protegidos de la clase Derivada.
Por lo tanto, otras clases no pueden usar miembros públicos de la clase Base a través del objeto Clase derivada; pero están disponibles para la subclase de Derivados.
3) Herencia privada :
a. Los miembros privados de la clase Base no son accesibles en la clase Derivada.
segundo. Los miembros protegidos y públicos de la clase Base se convierten en miembros privados de la clase Derivada.
Por lo tanto, a los miembros de la clase Derivada no se puede acceder a los miembros de la clase Base, ya que son privados en la clase Derivada Entonces, incluso la subclase de la clase Derivada no puede acceder a ellos.
Accessors | Base Class | Derived Class | World
—————————————+————————————+———————————————+———————
public | y | y | y
—————————————+————————————+———————————————+———————
protected | y | y | n
—————————————+————————————+———————————————+———————
private | | |
or | y | n | n
no accessor | | |
y: accessible
n: not accessible
Basado en this ejemplo para java ... Creo que una mesita vale más que mil palabras :)
Member in base class : Private Protected Public
Tipo de herencia : Objeto heredado como :
Private : Inaccessible Private Private
Protected : Inaccessible Protected Protected
Public : Inaccessible Protected Public
class A
{
public:
int x;
protected:
int y;
private:
int z;
};
class B : public A
{
// x is public
// y is protected
// z is not accessible from B
};
class C : protected A
{
// x is protected
// y is protected
// z is not accessible from C
};
class D : private A // ''private'' is default for classes
{
// x is private
// y is private
// z is not accessible from D
};
NOTA IMPORTANTE: las clases B, C y D contienen todas las variables x, y y z. Es solo cuestión de acceso.
Sobre el uso de la herencia protegida y privada puede leer here .