Découpage d'objets en C++

Cet article présentera le découpage d’objets en C++.

Utiliser le découpage d’objets pour dériver l’objet de classe dans la classe de base en C++

Le concept de base de la programmation orientée objet est l’héritage, ce qui implique que les classes peuvent être liées les unes aux autres et former une hiérarchie. La racine de la hiérarchie est généralement appelée classe de base dont d’autres classes héritent des fonctionnalités sous la forme de membres de données ou de fonctions. Les classes qui héritent d’autres classes sont appelées dérivées. Il existe différents types d’héritage qui spécifient le contrôle d’accès pour les membres de la classe de base et lesquels d’entre eux sont accessibles dans la classe dérivée. Par exemple, les membres privés de la classe de base ne sont pas accessibles directement à partir de la classe dérivée. Au lieu de cela, une classe dérivée doit utiliser des méthodes public pour récupérer ces membres. La classe de base peut désigner un ensemble distinct de membres avec un identifiant protected accessible directement depuis les classes dérivées.

Dans ce cas, nous nous concentrons sur les règles de conversion dérivées vers la base et les cas d’utilisation de ces fonctionnalités. Généralement, les classes dérivées contiennent des membres non statiques définis dans la classe dérivée elle-même et tous les membres hérités des autres classes. Lorsqu’un objet dérivé est affecté à un objet de classe de base, une exécution d’opérateur d’affectation est extraite de la classe de base. Ainsi, cet opérateur ne connaît que les membres de la classe de base, et seuls ces membres sont copiés lors de l’opération d’affectation.

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

Production:

Lua D
Lua

L’exemple de code précédent définit deux classes, Politician et Athlete, dérivées de la classe Person. Ainsi, on peut attribuer l’objet Politician à la Person, mais pas autrement. Lorsque l’affectation est terminée, la fonction membre getParty n’est pas accessible dans l’objet p0 nouvellement créé. Par conséquent, la version suivante du code entraîne une erreur de compilation puisque le p0 invoque un membre de la 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;
}