c++ - podem - exemplo de classe em c



Diferença entre herança privada, pública e protegida (10)

Privado:

Os membros privados de uma classe base só podem ser acessados ​​por membros dessa classe base.

Público:

Os membros públicos de uma classe base podem ser acessados ​​por membros dessa classe base, membros de sua classe derivada, bem como os membros que estão fora da classe base e da classe derivada.

Protegido:

Os membros protegidos de uma classe base podem ser acessados ​​por membros da classe base, bem como por membros de sua classe derivada.

Em resumo:

privado : base

protegido : base + derivado

public : base + derived + qualquer outro membro

Qual é a diferença entre herança public , private e protected em C ++? Todas as questões que encontrei no SO lidam com casos específicos.


É essencialmente a proteção de acesso dos membros públicos e protegidos da classe base na classe derivada. Com herança pública, a classe derivada pode ver membros públicos e protegidos da base. Com herança privada, não pode. Com protected, a classe derivada e quaisquer classes derivadas dela podem vê-las.


Eu encontrei uma resposta fácil e pensei em postá-lo para a minha referência futura também.

É dos links 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
}

Herança pública modela um relacionamento IS-A. Com

class B {};
class D : public B {};

todo D é um B

Modelos de herança privada um relacionamento IS-IMPLEMENTE-USING (ou o que quer que seja chamado). Com

class B {};
class D : private B {};

um D não é um B , mas todo D usa seu B em sua implementação. Herança privada sempre pode ser eliminada usando confinamento em vez disso:

class B {};
class D {
  private: 
    B b_;
};

Este D também pode ser implementado usando B , neste caso usando seu b_ . A contenção é um acoplamento menos rígido entre os tipos do que a herança, portanto, em geral, deve ser preferível. Às vezes, usar a contenção em vez da herança privada não é tão conveniente quanto a herança privada. Muitas vezes essa é uma desculpa tola para ser preguiçoso.

Eu não acho que alguém sabe o que protected modelos de herança. Pelo menos eu não vi nenhuma explicação convincente ainda.


Membros de dados protegidos podem ser acessados ​​por qualquer classe que herda da sua classe. Membros de dados privados, no entanto, não podem. Vamos supor que temos o seguinte:

class MyClass {
    private:
        int myPrivateMember;    // lol
    protected:
        int myProtectedMember;
};

De dentro de sua extensão para esta classe, referenciar this.myPrivateMember não funcionará. No entanto, this.myProtectedMember irá. O valor ainda é encapsulado, portanto, se tivermos uma instanciação dessa classe chamada myObj , então myObj.myProtectedMember não funcionará, portanto, é semelhante em função a um membro de dados privados.


Para responder a essa pergunta, gostaria de descrever os acessadores do membro primeiro com minhas próprias palavras. Se você já sabe disso, pule para o título "next:".

Existem três acessores que eu conheço: public , protected e private .

Deixei:

class Base {
    public:
        int publicMember;
    protected:
        int protectedMember;
    private:
        int privateMember;
};
  • Tudo o que está ciente do Base também está ciente de que Base contém publicMember .
  • Somente as crianças (e seus filhos) sabem que o Base contém protectedMember .
  • Ninguém além do Base está ciente do privateMember .

Por "está ciente de", quero dizer "reconhecer a existência de, e, portanto, ser capaz de acessar".

Próximo:

O mesmo acontece com a herança pública, privada e protegida. Vamos considerar uma classe Base e uma classe Child que herda da Base .

  • Se a herança for public , tudo o que estiver ciente de Base e Child também está ciente de que Child herda de Base .
  • Se a herança estiver protected , somente Child e seus filhos estão cientes de que eles herdam da Base .
  • Se a herança for private , ninguém além de Child está ciente da herança.

Se você herdar publicamente de outra classe, todo mundo sabe que você está herdando e você pode ser usado polimorficamente por qualquer pessoa através de um ponteiro de classe base.

Se você herdar de forma protegida, somente as classes de seus filhos poderão usá-lo polimorficamente.

Se você herdar de maneira privada, somente você poderá executar métodos de classe pai.

O que basicamente simboliza o conhecimento que o resto das classes tem sobre seu relacionamento com sua classe pai


Tem a ver com como os membros públicos da classe base são expostos da classe derivada.

  • público -> os membros públicos da classe base serão públicos (geralmente o padrão)
  • protected -> os membros públicos da classe base serão protegidos
  • private -> os membros públicos da classe base serão privados

Como pouco se nota, herança pública é herança tradicional que você verá na maioria das linguagens de programação. Isto é, modela um relacionamento "IS-A". Herança privada, algo AFAIK peculiar ao C ++, é um relacionamento "IMPLEMENTADO EM TERMOS DE". Você quer usar a interface pública na classe derivada, mas não quer que o usuário da classe derivada tenha acesso a essa interface. Muitos argumentam que, nesse caso, você deve agregar a classe base, ou seja, em vez de ter a classe base como uma base privada, faça um membro derivado para reutilizar a funcionalidade da classe base.


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: Todas as classes B, C e D contêm as variáveis ​​x, y e z. É apenas questão de acesso.

Sobre o uso de herança protegida e privada, você pode ler here .


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

Baseado this exemplo para java ... acho que uma pequena mesa vale mais que mil palavras :)





c++-faq