Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Linguagem C

Herança C++

Herança C++


Neste tutorial, aprenderemos sobre herança em C++ com a ajuda de exemplos.

A herança é um dos principais recursos da programação orientada a objetos em C++. Ele nos permite criar uma nova classe (classe derivada) a partir de uma classe existente (classe base).

A classe derivada herda os recursos da classe base e pode ter recursos adicionais próprios. Por exemplo,

class Animal {
    // eat() function
    // sleep() function
};

class Dog : public Animal {
    // bark() function
};

Aqui, o Dog classe é derivada do Animal classe. Desde Dog é derivado de Animal , membros de Animal são acessíveis a Dog .

Observe o uso da palavra-chave public ao herdar Cão de Animal.
class Dog : public Animal {...};

Também podemos usar as palavras-chave private e protected em vez de public . Aprenderemos sobre as diferenças entre usar private , public e protected posteriormente neste tutorial.

é-um relacionamento


A herança é um relacionamento é-um . Usamos herança apenas se um relacionamento é um está presente entre as duas classes.

aqui estão alguns exemplos:
  • Um carro é um veículo.
  • Laranja é uma fruta.
  • Um cirurgião é um médico.
  • Um cachorro é um animal.

Exemplo 1:Exemplo simples de herança C++

// C++ program to demonstrate inheritance

#include <iostream>
using namespace std;

// base class
class Animal {

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }
};

// derived class
class Dog : public Animal {
 
   public:
    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();

    // Calling member of the derived class
    dog1.bark();

    return 0;
}



Saída
I can eat!
I can sleep!
I can bark! Woof woof!!

Aqui, cão1 (o objeto da classe derivada Dog ) pode acessar membros da classe base Animal . É porque Dog é herdado de Animal .
// Calling members of the Animal class
dog1.eat();
dog1.sleep();

Membros protegidos por C++


O modificador de acesso protected é especialmente relevante quando se trata de herança C++.

Curtir private membros, protected membros são inacessíveis fora da classe. No entanto, eles podem ser acessados ​​por classes derivadas e classes/funções de amigos .

Precisamos de protected membros se quisermos ocultar os dados de uma classe, mas ainda queremos que esses dados sejam herdados por suas classes derivadas.

Para saber mais sobre protegido, consulte nosso tutorial sobre modificadores de acesso C++.

Exemplo 2:Membros protegidos por C++

// C++ program to demonstrate protected members

#include <iostream>
#include <string>
using namespace std;

// base class
class Animal {

   private:
    string color;

   protected:
    string type;

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }

    void setColor(string clr) {
        color = clr;
    }

    string getColor() {
        return color;
    }
};

// derived class
class Dog : public Animal {

   public:
    void setType(string tp) {
        type = tp;
    }

    void displayInfo(string c) {
        cout << "I am a " << type << endl;
        cout << "My color is " << c << endl;
    }

    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();
    dog1.setColor("black");

    // Calling member of the derived class
    dog1.bark();
    dog1.setType("mammal");

    // Using getColor() of dog1 as argument
    // getColor() returns string data
    dog1.displayInfo(dog1.getColor());

    return 0;
}

Saída
I can eat!
I can sleep!
I can bark! Woof woof!!
I am a mammal
My color is black

Aqui, a variável tipo é protected e, portanto, é acessível a partir da classe derivada Dog . Podemos ver isso quando inicializamos type no Dog classe usando a função setType() .

Por outro lado, o private variável cor não pode ser inicializado em Dog .
class Dog : public Animal {

    public:
      void setColor(string clr) {
          // Error: member "Animal::color" is inaccessible
          color = clr; 
      }
};

Além disso, como o protected palavra-chave oculta dados, não podemos acessar tipo diretamente de um objeto de Dog ou Animal classe.
// Error: member "Animal::type" is inaccessible
dog1.type = "mammal";

Modos de acesso na herança C++


Em nossos tutoriais anteriores, aprendemos sobre especificadores de acesso C++, como público, privado e protegido.

Até agora, usamos o public palavra-chave para herdar uma classe de uma classe base já existente. No entanto, também podemos usar o private e protected palavras-chave para herdar classes. Por exemplo,
class Animal {
    // code
};

class Dog : private Animal {
    // code
};
class Cat : protected Animal {
    // code
};

As várias maneiras de derivar classes são conhecidas como modos de acesso . Esses modos de acesso têm o seguinte efeito:
  1. público: Se uma classe derivada for declarada em public mode, então os membros da classe base são herdados pela classe derivada exatamente como estão.
  2. privado: Nesse caso, todos os membros da classe base se tornam private membros na classe derivada.
  3. protegido: O public membros da classe base se tornam protected membros na classe derivada.

O private membros da classe base são sempre private na classe derivada.

Para saber mais, visite nosso tutorial de herança pública, privada e protegida de C++.

Substituição de função de membro na herança


Suponha que a classe base e a classe derivada tenham funções-membro com o mesmo nome e argumentos.

Se criarmos um objeto da classe derivada e tentarmos acessar essa função-membro, a função-membro da classe derivada será invocada em vez da da classe base.

A função membro da classe derivada substitui a função membro da classe base.

Saiba mais sobre substituição de função em C++.


Leitura recomendada: Herança múltipla de C++

Linguagem C

  1. Palavra-chave estática C#
  2. Classe aninhada C#
  3. Operadores C++
  4. Classes e objetos C++
  5. Herança pública, protegida e privada C++
  6. Modelos de classe C++
  7. Herança Python
  8. Classes de armazenamento em C++
  9. Polimorfismo em C++
  10. Abstração de dados em C++