Héritage des constructeurs en C++

1. Héritage en C++
2. Implémentation de l’héritage en C++
3. Héritage de constructeur en C++

Cet article porte sur le concept d’héritage en C++ et sur la façon dont nous pouvons hériter des constructeurs de la classe de base dans la classe dérivée.

Héritage en C++

En C++, en particulier dans la programmation orientée objet, le concept le plus fondamental et le plus largement utilisé est celui d’héritage. C’est une fonctionnalité dans laquelle nous pouvons définir une classe comme une classe enfant d’une autre.

Cela nous permet également de réutiliser certaines fonctionnalités du code et réduit notre temps de mise en œuvre. Cela nous permet de dériver les fonctionnalités et les propriétés de la classe de base dans la classe dérivée.

1. Classe de base - La classe dont les propriétés et les fonctionnalités sont utilisées par une autre classe est appelée la classe de base. Il est parfois aussi appelé super-classe.
2. Classe dérivée - La classe qui reprend les propriétés et les fonctionnalités d’une autre classe est appelée la classe dérivée. Il est parfois aussi appelé sous-classe.

Prenons un exemple de certains véhicules. La voiture, le bus et le camion sont tous des automobiles, et toutes ces automobiles ont des caractéristiques communes, et certaines sont différentes.

Comme ce sont tous des automobiles et que toutes les automobiles ont des fonctionnalités qui sont uniformes entre toutes. Si nous créons des classes pour toutes ces automobiles, nous ferons beaucoup de duplication de code.

Ceci est illustré dans la figure ci-dessous.

Vous pouvez voir sur l’image ci-dessus que toutes les automobiles ont les mêmes fonctionnalités. Cela créera une duplication de code trois fois.

La duplication de code donne naissance à de nombreux autres problèmes tels que les risques d’erreurs, l’augmentation du temps de traitement, etc. L’héritage est utilisé pour surmonter de telles situations.

Nous pouvons créer une classe Automobile composée de toutes ces fonctionnalités et dériver les classes restantes avec cette classe. Grâce à cela, nous pouvons réduire la duplication de code et augmenter la réutilisabilité du code.

Vous pouvez voir sur l’image ci-dessus que nous avons réduit le code en double et que toutes les fonctionnalités sont incluses dans toutes les classes. L’héritage définit généralement une relation est-un.

Par exemple, une voiture est une automobile, un cercle est une forme, un chien est un animal, etc.

Implémentation de l’héritage en C++

Nous devons suivre la syntaxe suivante pour dériver une sous-classe d’une classe de base.

class derived - class - name : access - specifier base - class - name { .. }

Ce spécificateur d’accès est là pour décider comment nous devons hériter des fonctionnalités de la classe de base. Que nous ayons besoin de tous ou de certains d’entre eux est décidé en fonction du spécificateur d’accès.

Il peut être public, private ou protected. Si nous ne spécifions pas le spécificateur d’accès, il est private par défaut.

Exemple:

public
class Automobile {
 public:
  getFuelAmount();
  applyBrakes();
  startEngine();
  stopEngine();
} public class Car : public Automobile {
  pressHorn();
} public class Bus : public Automobile {
  pressHorn();
}

Vous pouvez voir dans le code ci-dessus que les deux classes dérivées n’ont qu’une seule fonction qui n’est pas uniforme pour les deux, car le son du klaxon est différent pour tous les véhicules. Par conséquent, nous avons créé cette fonction dans la classe dérivée, et le reste est dans la classe de base.

Prenons un autre exemple de la classe Shapes.

#include <iostream>
#include <string>
using namespace std;
class Shapes {
 public:
  int w;
  int h;
};
class Square : public Shapes {
 public:
  int getArea() { return w * h; }
};
int main() {
  Square s;
  s.w = 5;
  s.h = 5;
  cout << "Area: " << s.getArea() << endl;
  return 0;
}

Production:

Area: 25

Héritage de constructeur en C++

Nous pouvons voir à partir de l’exemple précédent que les fonctions et les propriétés sont héritées dans la classe dérivée comme dans la classe de base. Mais si nous devons appeler le constructeur de la classe de base, nous devons l’appeler explicitement dans le constructeur de la classe dérivée.

Les constructeurs ne sont pas appelés automatiquement. Prenons un exemple ci-dessous.

#include <iostream>
using namespace std;
class baseClass {
 public:
  baseClass() { cout << "In constructor: Base" << endl; }
};
class derivedClass : public baseClass {
 public:
  derivedClass() : baseClass() { cout << "In Constructor: derived" << endl; }
};
int main() {
  derivedClass d;
  cout << "In main" << endl;
}

Production:

In constructor: Base
In Constructor: derived
In main

En C++11, cela peut être fait en utilisant using-declaration. Avec using-declaration, nous pouvons utiliser une fonction de classe dérivée dans la classe de base.

L’exemple ci-dessus peut être modifié comme suit.

#include <iostream>
using namespace std;
class baseClass {
 public:
  baseClass() { cout << "In constructor: Base" << endl; }
};
class derivedClass : public baseClass {
  using baseClass::baseClass;

 public:
  derivedClass() { cout << "In Constructor: derived" << endl; }
};
int main() {
  derivedClass d;
  cout << "In main" << endl;
}

Cela donnera également le même résultat.

In constructor: Base
In Constructor: derived
In main