Affettare gli oggetti in C++

Questo articolo introdurrà lo slicing degli oggetti in C++.

Usa l’affettatura dell’oggetto per l’oggetto di classe derivato nella classe base in C++

Il concetto centrale della programmazione orientata agli oggetti è l’ereditarietà, il che implica che le classi possono essere correlate tra loro e formare una gerarchia. La radice della gerarchia è generalmente chiamata classe base da cui altre classi ereditano caratteristiche sotto forma di membri dati o funzioni. Le classi che ereditano da altre classi sono chiamate derivate. Esistono diversi tipi di ereditarietà che specificano il controllo di accesso per i membri della classe di base e quali di essi sono accessibili nella classe derivata. Ad esempio, non è possibile accedere direttamente ai membri privati ​​della classe base dalla classe derivata. Invece, una classe derivata dovrebbe utilizzare metodi public per recuperare questi membri. La classe base può designare un insieme separato di membri con un identificatore protetto accessibile direttamente dalle classi derivate.

In questo caso, ci concentriamo sulle regole di conversione da derivate a base e sui casi d’uso per tali funzionalità. In genere, le classi derivate contengono membri non statici definiti nella classe derivata stessa e tutti i membri ereditati dalle altre classi. Quando un oggetto derivato viene assegnato a un oggetto della classe di base, viene eseguita un’esecuzione dell’operatore di assegnazione dalla classe di base. Pertanto, questo operatore conosce solo i membri della classe base e solo quei membri vengono copiati durante l’operazione di assegnazione.

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

Produzione:

Lua D
Lua

Il codice di esempio precedente definisce due classi, Politician e Athlete, derivate dalla classe Person. Quindi, possiamo assegnare l’oggetto Politico alla Person, ma non in un altro modo. Al termine dell’assegnazione, la funzione membro getParty non è accessibile nell’oggetto p0 appena creato. Di conseguenza, la seguente versione del codice risulta in un errore in fase di compilazione poiché p0 richiama un membro della 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;
}