División de objetos en C++

Este artículo presentará la división de objetos en C++.

Use Object Slicing para derivar un objeto de clase a la clase base en C++

El concepto central de la programación orientada a objetos es la herencia, lo que implica que las clases pueden estar relacionadas entre sí y formar una jerarquía. La raíz de la jerarquía generalmente se denomina clase base de la cual otras clases heredan características en forma de miembros de datos o funciones. Las clases que heredan de otras clases se denominan derivadas. Existen diferentes tipos de herencia que especifican el control de acceso para los miembros de la clase base y cuáles de ellos son accesibles en la clase derivada. Por ejemplo, no se puede acceder a los miembros privados de la clase base directamente desde la clase derivada. En cambio, una clase derivada debería utilizar métodos public para recuperar estos miembros. La clase base puede designar un conjunto separado de miembros con un identificador protected accesible directamente desde las clases derivadas.

En este caso, nos centramos en las reglas de conversión derivadas a base y los casos de uso de dichas funciones. Normalmente, las clases derivadas contienen miembros no estáticos definidos en la propia clase derivada y todos los miembros que se heredan de las otras clases. Cuando un objeto derivado se asigna a un objeto de clase base, se toma una ejecución de operador de asignación de la clase base. Por lo tanto, este operador solo conoce los miembros de la clase base y solo esos miembros se copian durante la operación de asignación.

#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;
}

Producción :

Lua D
Lua

El código de ejemplo anterior define dos clases, Politician y Athlete, derivadas de la clase Person. Entonces, podemos asignar el objeto Político a la Person, pero no al revés. Cuando se realiza la asignación, la función miembro getParty no es accesible en el objeto p0 recién creado. En consecuencia, la siguiente versión del código da como resultado un error en tiempo de compilación ya que p0 invoca a un miembro de la clase 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;
}