Fatiamento de objetos em C++
Este artigo apresentará a divisão de objetos em C++.
Use a divisão de objetos para derivar objetos de classe para a classe base em C++
O conceito central da programação orientada a objetos é a herança, o que implica que as classes podem estar relacionadas entre si e formar uma hierarquia. A raiz da hierarquia é geralmente chamada de classe base da qual outras classes herdam recursos na forma de membros de dados ou funções. As classes que herdam de outras classes são chamadas de classes derivadas. Existem diferentes tipos de herança que especificam o controle de acesso para os membros da classe base e quais deles são acessíveis na classe derivada. Por exemplo, membros privados da classe base não podem ser acessados diretamente da classe derivada. Em vez disso, uma classe derivada deve usar métodos public para recuperar esses membros. A classe base pode designar um conjunto separado de membros com um identificador protected acessível diretamente das classes derivadas.
Nesse caso, nos concentramos nas regras de conversão derivada para base e nos casos de uso para tais recursos. Normalmente, as classes derivadas contêm membros não estáticos definidos na própria classe derivada e todos os membros que são herdados de outras classes. Quando um objeto derivado é atribuído a um objeto da classe base, uma execução do operador de atribuição é obtida da classe base. Portanto, esse operador conhece apenas os membros da classe base e apenas esses membros são copiados durante a operação de atribuição.
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
using std::string;
class Person {
protected:
string name;
public:
explicit Person(string s) : name(std::move(s)) {}
string getName() { return name; };
};
class Athlete : public Person {
string sport;
public:
explicit Athlete(string s) : Person(std::move(s)){};
Athlete(string s, string sp) : Person(std::move(s)), sport(std::move(sp)){};
string getSport() { return sport; }
};
class Politician : public Person {
string party;
public:
explicit Politician(string s) : Person(std::move(s)) {}
Politician(string s, string p) : Person(std::move(s)), party(std::move(p)) {}
string getParty() { return party; }
};
int main() {
Politician p1("Lua", "D");
Athlete a1("Lebron", "LA Lakers");
cout << p1.getName() << " " << p1.getParty() << endl;
Person p0 = p1;
Athlete a2(p0.getName());
cout << p0.getName() << endl;
cout << a2.getName() << endl;
return EXIT_SUCCESS;
}
Resultado:
Lua D
Lua
O código do exemplo anterior define duas classes, Politician e Athlete, derivadas da classe Person. Assim, podemos atribuir o objeto Politician à Person, mas não de outra forma. Quando a atribuição é concluída, a função de membro getParty não está acessível no objeto p0 recém-criado. Conseqüentemente, a seguinte versão do código resulta em um erro em tempo de compilação, uma vez que p0 invoca um membro da classe Politician.
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
using std::string;
class Person {
protected:
string name;
public:
explicit Person(string s) : name(std::move(s)) {}
string getName() { return name; };
};
class Athlete : public Person {
string sport;
public:
explicit Athlete(string s) : Person(std::move(s)){};
Athlete(string s, string sp) : Person(std::move(s)), sport(std::move(sp)){};
string getSport() { return sport; }
};
class Politician : public Person {
string party;
public:
explicit Politician(string s) : Person(std::move(s)) {}
Politician(string s, string p) : Person(std::move(s)), party(std::move(p)) {}
string getParty() { return party; }
};
int main() {
Politician p1("Lua", "D");
Athlete a1("Lebron", "LA Lakers");
cout << p1.getName() << " " << p1.getParty() << endl;
Person p0 = p1;
Politician p2 = p0;
Politician p2 = a1;
cout << p0.getName() << " " << p0.getParty() << endl;
return EXIT_SUCCESS;
}
Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.
LinkedIn Facebook