Programmation orientée objet – Comme son nom l'indique, utilise des objets dans la programmation. La programmation orientée objet vise à implémenter des entités du monde réel telles que l'héritage, le masquage, le polymorphisme, etc. dans la programmation. L'objectif principal de la POO est de relier les données et les fonctions qui y opèrent afin qu'aucune autre partie du code ne puisse accéder à ces données à l'exception de cette fonction.

Certains concepts de base servent de base aux POO, à savoir :

1. Classe
2. Objets
3. Encapsulation
4. Abstraction
5. Polymorphisme
6. Héritage
7. Liaison dynamique
8. Passage de messages

Caractéristiques d'un langage de programmation orienté objet

entier pour doubler Java

Classe

La pierre angulaire du C++ qui mène à la programmation orientée objet est une classe. Il s'agit d'un type de données défini par l'utilisateur, qui contient ses propres données membres et fonctions membres, accessibles et utilisées en créant une instance de cette classe. Une classe est comme un modèle pour un objet. Par exemple : considérez la classe de voitures. Il peut y avoir de nombreuses voitures avec des noms et des marques différents, mais toutes partageront des propriétés communes, comme elles auront toutes 4 roues, une limite de vitesse, une plage de kilométrage, etc. Donc ici, la voiture est la classe, et les roues, les limites de vitesse , et le kilométrage sont leurs propriétés.

• Une classe est un type de données défini par l'utilisateur qui comporte des données membres et des fonctions membres.
• Les données membres sont les variables de données et les fonctions membres sont les fonctions utilisées pour manipuler ces variables ensemble. Ces données membres et fonctions membres définissent les propriétés et le comportement des objets dans une classe.
• Dans l'exemple ci-dessus de la classe Car, le membre de données sera la limite de vitesse, le kilométrage, etc. et les fonctions membres peuvent appliquer les freins, augmenter la vitesse, etc.

On peut dire qu'un Cours en C++ est un plan représentant un groupe d'objets qui partagent certaines propriétés et comportements communs.

Objet

Un objet est une entité identifiable avec certaines caractéristiques et comportements. Un objet est une instance d'une classe. Lorsqu'une classe est définie, aucune mémoire n'est allouée mais lorsqu'elle est instanciée (c'est-à-dire qu'un objet est créé), la mémoire est allouée.

// C++ Program to show the syntax/working of Objects as a // part of Object Oriented PProgramming #include  using namespace std; class person {  char name[20];  int id; public:  void getdetails() {} }; int main() {  person p1; // p1 is a object  return 0; }>

Les objets prennent de la place en mémoire et ont une adresse associée comme un enregistrement en pascal ou une structure ou une union. Lorsqu'un programme est exécuté, les objets interagissent en s'envoyant des messages. Chaque objet contient des données et du code pour manipuler les données. Les objets peuvent interagir sans avoir à connaître les détails des données ou du code de chacun, il suffit de connaître le type de message accepté et le type de réponse renvoyée par les objets.

Pour en savoir plus sur les objets et classes C++, reportez-vous à cet article – Classes et objets C++

Encapsulation

En termes normaux, l'encapsulation est définie comme le regroupement de données et d'informations sous une seule unité. Dans la programmation orientée objet, l'encapsulation est définie comme la liaison des données et des fonctions qui les manipulent. Prenons un exemple réel d'encapsulation, dans une entreprise, il existe différentes sections comme la section comptabilité, la section finance, la section ventes, etc. La section finance gère toutes les transactions financières et conserve des enregistrements de toutes les données liées à la finance. De même, la section des ventes gère toutes les activités liées aux ventes et tient un registre de toutes les ventes. Il peut désormais arriver que, pour une raison quelconque, un responsable de la section des finances ait besoin de toutes les données sur les ventes d'un mois donné. Dans ce cas, il n’est pas autorisé à accéder directement aux données de la section vente. Il devra d'abord contacter un autre agent du service des ventes et lui demander ensuite de fournir les données particulières. C'est ce qu'est l'encapsulation. Ici, les données de la section de vente et les employés qui peuvent les manipuler sont regroupées sous une section de vente à nom unique.

Encapsulation en C++

L'encapsulation conduit également à abstraction de données ou masquage de données . L'utilisation de l'encapsulation masque également les données. Dans l'exemple ci-dessus, les données de l'une des sections telles que les ventes, les finances ou les comptes sont masquées de toute autre section.

Pour en savoir plus sur l'encapsulation, reportez-vous à cet article – Encapsulation en C++

Abstraction

L'abstraction des données est l'une des fonctionnalités les plus essentielles et les plus importantes de la programmation orientée objet en C++. L'abstraction signifie afficher uniquement les informations essentielles et masquer les détails. L'abstraction des données consiste à fournir uniquement des informations essentielles sur les données au monde extérieur, en masquant les détails de base ou la mise en œuvre. Prenons l’exemple réel d’un homme conduisant une voiture. L'homme sait seulement qu'appuyer sur l'accélérateur augmentera la vitesse de la voiture ou que l'application des freins arrêtera la voiture, mais il ne sait pas comment en appuyant sur l'accélérateur la vitesse augmente réellement, il ne connaît pas le mécanisme interne de la voiture ou la mise en place d'un accélérateur, de freins, etc. dans la voiture. C’est ça l’abstraction.

nginx

• Abstraction utilisant des classes : Nous pouvons implémenter l'abstraction en C++ en utilisant des classes. La classe nous aide à regrouper les données membres et les fonctions membres à l'aide des spécificateurs d'accès disponibles. Une classe peut décider quels membres de données seront visibles par le monde extérieur et lesquels ne le seront pas.
• Abstraction dans les fichiers d'en-tête : Un autre type d'abstraction en C++ peut être les fichiers d'en-tête. Par exemple, considérons la méthode pow() présente dans le fichier d'en-tête math.h. Chaque fois que nous avons besoin de calculer la puissance d'un nombre, nous appelons simplement la fonction pow() présente dans le fichier d'en-tête math.h et passons les nombres en arguments sans connaître l'algorithme sous-jacent selon lequel la fonction calcule réellement la puissance des nombres. .

Pour en savoir plus sur l'abstraction C++, reportez-vous à cet article – Abstraction en C++

Polymorphisme

Le mot polymorphisme signifie avoir plusieurs formes. En termes simples, nous pouvons définir le polymorphisme comme la capacité d’un message à s’afficher sous plusieurs formes. Une personne peut avoir différentes caractéristiques en même temps. Un homme est à la fois père, mari et employé. Ainsi, la même personne possède un comportement différent dans différentes situations. C'est ce qu'on appelle le polymorphisme. Une opération peut présenter différents comportements dans différentes instances. Le comportement dépend des types de données utilisés dans l'opération. C++ prend en charge la surcharge d'opérateurs et la surcharge de fonctions.

• Surcharge de l'opérateur : Le processus consistant à faire en sorte qu'un opérateur présente différents comportements dans différentes instances est connu sous le nom de surcharge d'opérateur.
• Surcharge de fonctions : La surcharge de fonctions consiste à utiliser un seul nom de fonction pour effectuer différents types de tâches. Le polymorphisme est largement utilisé dans la mise en œuvre de l'héritage.

Exemple : Supposons que nous devions écrire une fonction pour ajouter des entiers, parfois il y a 2 entiers, et parfois il y a 3 entiers. On peut écrire la Méthode Addition du même nom ayant des paramètres différents, la méthode concernée sera appelée en fonction des paramètres.

Polymorphisme en C++

Pour en savoir plus sur le polymorphisme, référez-vous à cet article – Polymorphisme en C++

Héritage

La capacité d’une classe à dériver des propriétés et des caractéristiques d’une autre classe est appelée Héritage . L'héritage est l'une des fonctionnalités les plus importantes de la programmation orientée objet.

• Sous-classe : La classe qui hérite des propriétés d'une autre classe est appelée Sous-classe ou Classe dérivée.
• Super Classe : La classe dont les propriétés sont héritées par une sous-classe est appelée Classe de Base ou Superclasse.
• Réutilisabilité : L'héritage prend en charge le concept de réutilisabilité, c'est-à-dire que lorsque nous voulons créer une nouvelle classe et qu'il existe déjà une classe qui inclut une partie du code que nous voulons, nous pouvons dériver notre nouvelle classe de la classe existante. En faisant cela, nous réutilisons les champs et les méthodes de la classe existante.

Exemple : Chien, Chat, Vache peuvent être des classes dérivées de la classe de base animale.

Héritage en C++

Pour en savoir plus sur l'héritage, reportez-vous à cet article – Héritage en C++

jframe

Liaison dynamique

Dans la liaison dynamique, le code à exécuter en réponse à l'appel de fonction est décidé au moment de l'exécution. C++ a fonctions virtuelles pour soutenir cela. La liaison dynamique étant flexible, elle évite les inconvénients de la liaison statique, qui reliait l'appel de fonction et la définition au moment de la construction.

Exemple:

// C++ Program to Demonstrate the Concept of Dynamic binding // with the help of virtual function #include  using namespace std; class GFG { public:  void call_Function() // function that call print  {  print();  }  void print() // the display function  {  cout << 'Printing the Base class Content' << endl;  } }; class GFG2 : public GFG // GFG2 inherit a publicly { public:  void print() // GFG2's display  {  cout << 'Printing the Derived class Content'  << endl;  } }; int main() {  GFG geeksforgeeks; // Creating GFG's object  geeksforgeeks.call_Function(); // Calling call_Function  GFG2 geeksforgeeks2; // creating GFG2 object  geeksforgeeks2.call_Function(); // calling call_Function  // for GFG2 object  return 0; }>

Printing the Base class Content Printing the Base class Content>

Comme nous pouvons le voir, la fonction print() de la classe parent est appelée même à partir de l'objet de classe dérivé. Pour résoudre ce problème, nous utilisons des fonctions virtuelles.

Exemple ci-dessus avec fonction virtuelle :

#include using namespace std; class GFG { public:  void call_Function() // function that call print  {  print();  }  virtual void print() // using 'virtual' for the display function   {  cout << 'Printing the Base class Content' << endl;  } }; class GFG2 : public GFG // GFG2 inherit a publicly { public:  void print() // GFG2's display  {  cout << 'Printing the Derived class Content'  << endl;  } }; int main() {  GFG geeksforgeeks; // Creating GFG's object  geeksforgeeks.call_Function(); // Calling call_Function  GFG2 geeksforgeeks2; // creating GFG2 object  geeksforgeeks2.call_Function(); // calling call_Function  // for GFG2 object  return 0; } //this code is contributed by Md Nizamuddin>

Printing the Base class Content Printing the Derived class Content>

Passage de messages

Les objets communiquent entre eux en envoyant et en recevant des informations. Un message pour un objet est une demande d'exécution d'une procédure et invoquera donc une fonction dans l'objet récepteur qui génère les résultats souhaités. Le passage de messages implique de spécifier le nom de l'objet, le nom de la fonction et les informations à envoyer.

Exemple:

#include  using namespace std; // Define a Car class with a method to display its speed class Car { public:  void displaySpeed(int speed) {  cout << 'The car is moving at ' << speed << ' km/h.' << endl;  } }; int main() {  // Create a Car object named myCar  Car myCar;  // Send a message to myCar to execute the displaySpeed method  int currentSpeed = 100;  myCar.displaySpeed(currentSpeed);  return 0; } //this code is contributed by Md Nizamuddin>

Articles Liés :

• Classes et objets
• Héritage
• Modificateurs d'accès
• Abstraction