Apprendre C/C++ Étape par Étape - Page 13

13. Étape par Étape C/C++ — Programmation C++ - OOPs

OOP (Programmation Orientée Objet) en C++

| | 1. Paradigme Orienté Objet

2. Caractéristiques du Langage Orienté Objet

• Objets
• Classes
• Abstraction des données
• Encapsulation des données
• Héritage
• Polymorphisme
• Liaison dynamique
• Passage de messages

3. Histoire de C++
4. Classes et Objets
5. Fonctions membres définies en dehors de la classe
6. Tableau d’Objets
7. Objets comme Arguments
8. Retourner des Objets depuis des fonctions
9. Constructeur
10. Destructeurs
11. Surcharge de Constructeur
12. Données de Classe Statique
13. Fonctions Membres Statique
14. Fonctions Amies |

1. Paradigme Orienté Objet

L’idée de base derrière le Paradigme Orienté Objet est de combiner en une seule unité à la fois les données et les fonctions qui opèrent sur ces données. Une telle unité est appelée un objet.

Grâce à cette méthode, nous ne pouvons pas accéder aux données directement. Les données sont cachées, donc, elles sont à l’abri de toute altération accidentelle. Les données et ses fonctions sont dites encapsulées dans une seule entité. L’encapsulation des données et le masquage des données sont des termes clés dans la description du langage orienté objet.

Un programme C++ se compose généralement d’un certain nombre d’objets, qui communiquent entre eux en appelant les fonctions membres des uns et des autres. L’organisation d’un programme C++ est montrée dans cette figure.

| | |

2. Caractéristiques du Langage Orienté Objet

Voici quelques éléments majeurs des langages orientés objet.

| | - Objets

• Classes
• Abstraction des données
• Encapsulation des données
• Héritage
• Polymorphisme
• Liaison dynamique
• Passage de messages |

| |
Objets
Un objet est une instance d’une classe. Combinant à la fois des données et des fonctions membres. Les objets sont les entités de base à l’exécution dans un système orienté objet. | | |
Classes
Un modèle ou un plan qui définit les caractéristiques d’un objet et décrit comment l’objet doit apparaître et se comporter. | | |
Abstraction des Données
Identifier les caractéristiques distinctives d’une classe ou d’un objet sans avoir à traiter toutes les informations sur la classe ou l’objet. Lorsque vous créez une classe — par exemple, un ensemble de boutons de navigation de table — vous pouvez l’utiliser comme une seule entité au lieu de suivre les composants individuels et comment ils interagissent. | | |
Encapsulation des Données
Un terme de programmation orientée objet pour la capacité de contenir et de cacher des informations sur un objet, telles que les structures de données internes et le code. L’encapsulation isole la complexité interne de l’opération d’un objet du reste de l’application. Par exemple, lorsque vous définissez la propriété Caption sur un bouton de commande, vous n’avez pas besoin de savoir comment la chaîne est stockée. | | |
Héritage
Un terme de programmation orientée objet. La capacité d’une sous-classe à adopter les caractéristiques de la classe dont elle est dérivée. Si les caractéristiques de la classe parente changent, la sous-classe dont elle est dérivée hérite de ces caractéristiques.
Pour hériter des qualités de la classe de base à la classe dérivée. | | |
Polymorphisme
Un terme de programmation orientée objet. La capacité d’avoir des méthodes avec le même nom, mais un contenu différent, pour des classes apparentées. La procédure à utiliser est déterminée au moment de l’exécution par la classe de l’objet. Par exemple, des objets apparentés peuvent tous deux avoir des méthodes Draw. Une procédure, à laquelle un tel objet est passé comme paramètre, peut appeler la méthode Draw sans avoir besoin de savoir quel type d’objet est le paramètre. | | |
Liaison Dynamique
Dynamique fait référence à la liaison d’un appel de procédure au code à exécuter en réponse à l’appel. La liaison dynamique signifie que le code associé à un appel de procédure donné n’est pas connu jusqu’au moment de l’appel à l’exécution. Elle est associée au polymorphisme et à l’héritage. Un appel de fonction associé à une référence polymorphe dépend du type dynamique de cette référence. | | |
Passage de Messages
Un programme orienté objet se compose d’un ensemble d’objets qui communiquent entre eux. Le processus de programmation dans un langage orienté objet implique donc les étapes de base suivantes :

1. Créer des classes qui définissent des objets et leur comportement.
2. Créer des objets à partir des définitions de classe.
3. Établir une communication entre les objets. |

3. Histoire de C++

| 1970 | B | Ken Thompson
AT & T Bell Labs | Ne pouvait traiter que des problèmes spécifiques | | 1972 | C | Dennis Ritchie
AT & T Bell Labs | A perdu la généralité de BCPL et B restauré | | Début des années 80 | C++ | Bjarne Stroustrup
AT & T | Introduit OOPs. |

C++ est un langage de programmation orienté objet. Initialement nommé ‘C avec Classes’, C++ a été développé par Bjarne Stroustrup aux laboratoires Bell d’AT & T à Murry Hill, New Jersey, USA, au début des années quatre-vingt.

Stroustrup, un admirateur de Simula67 (un langage OOP) et un fervent supporter de C, voulait combiner le meilleur des deux langages et créer plus de puissance et d’élégance dans C. Le résultat fut C++.

C++ est un véritable Langage Orienté Objet, donc. Il doit être une collection de classes et d’objets.

4. Classes et Objets

Une classe est un moyen de lier les données et ses fonctions associées ensemble. Elle permet de cacher les données, si nécessaire, d’une utilisation externe. Lors de la définition d’une classe, nous créons un nouveau type de données abstrait qui peut être traité comme n’importe quel autre type de données intégré. En général, une spécification de classe a deux parties :

| | 1. Déclaration de classe

2. Définition de fonction de classe |

La déclaration spécifie le type et la portée des données et des fonctions membres de la classe. Tandis que la définition spécifie le code exécutable de la fonction.

La forme générale d’une déclaration de classe est :

| | class class_name
{
private:
variable declarations;
function declarations;
public:
variable declarations;
function declarations;
}; |

La déclaration de classe est similaire à la déclaration de struct. Le mot clé class spécifie que les données et les fonctions sont privées par défaut. Tandis qu’un mot clé struct spécifie que les données et les fonctions sont publiques par défaut. Les mots clés privé et public sont connus sous le nom d’étiquettes de visibilité.

| | |

Voici un exemple de classe pour implémenter une classe d’employé.

| | |

Le programme suivant est le programme complet de la classe emp.

| | // Programme pour accepter et afficher les informations de l’employé
#include
using namespace std;
class emp                                             // définition de la classe
{
private :                                     // données privées, fonctions
int eno;
char name[10];
float sal;
public :                                      // données publiques, fonctions
void getdata()
{ cin >> eno >> name >> sal;  }
void putdata()
{ cout << eno << name << sal;  }
};
int main()
{
emp e;
e.getdata();
e.putdata();
return 0;
} |

5. Fonctions membres définies en dehors de la classe

Il est possible de définir des fonctions membres en dehors de la classe en utilisant l’opérateur de résolution de portée (::).

| | // Programme pour accepter et afficher les informations de l’employé
#include
using namespace std;
class emp                                             // définition de la classe
{
private :                         // données privées, fonctions
int eno;
char name[10];
float sal;
public :                                      // données publiques, fonctions
void getdata();
void putdata();
};
void emp::getdata()
{   cin >> eno >> name >> sal;  }
void emp::putdata()
{   cout << eno << name << sal; }
int main()
{
emp e;
e.getdata();
e.putdata();
return 0;
} |

6. Tableau d’Objets

Le compilateur C++ prend également en charge les tableaux d’objets.
L’exemple ci-dessous illustre l’avantage des Objets utilisant des tableaux.

| | // Programme pour accepter et afficher les informations de l’employé
#include
using namespace std;
class emp                                             // définition de la classe
{
private :                         // données privées, fonctions
int eno;
char name[10];
float sal;
public :                                      // données publiques, fonctions
void getdata()
{ cin << eno << name << sal;  }
void putdata()
{ cout >> eno >> name >> sal;  }
};

int main()
{
emp e[10];                     // déclaration d’un tableau d’objets
for(i = 0; i <10; i++)        // accès aux propriétés et méthodes des objets
e[i].getdata();
for(i = 0; i< 10; i++)
e[i].putdata();
return 0;
} |

7. Objets comme Arguments

Passer des Objets à des fonctions est similaire à passer des structures, des tableaux à des fonctions. Le programme suivant démontre comment des objets sont passés à des fonctions.

| | // Programme pour accepter et afficher les informations de l’employé
#include
using namespace std;
class emp                                             // définition de la classe
{
private :                         // données privées, fonctions
int eno;
char name[10];
float sal;
public :                                      // données publiques, fonctions
void getdata()
{ cin >> eno >> name >> sal;  }
void putdata()
{ cout << eno << name << sal;  }
};
void operate(emp t);
int main()
{
emp e;
operate(e);
}
void operate(emp t)
{
t.getdata();
t.putdata();
return 0;
} |

8. Retourner des Objets depuis des fonctions

Nous avons vu des objets passés comme arguments à des fonctions, maintenant nous allons discuter de la façon de retourner des objets depuis des fonctions.

| | // Programme pour accepter et afficher les informations de l’employé
#include
using namespace std;
class emp                                             // définition de la classe
{
private :                         // données privées, fonctions
int eno;
char name[10];
float sal;
public :                                      // données publiques, fonctions
void getdata()
{ cin >> eno >> name >> sal;  }
void putdata()
{ cout << eno << name << sal;  }
};
emp get();
void put(emp t);
int main()
{
emp e;
e = get();
put(e);
return 0;
}
emp get()
{
emp t;
t.getdata();
return t;
}
void put(emp t)
{
t.putdata();
} |

9. Constructeur

L’exemple suivant montre deux façons de donner des valeurs aux éléments de données dans un objet. Parfois, cependant, il est pratique qu’un objet puisse s’initialiser lui-même lorsqu’il est créé pour la première fois, sans avoir besoin de faire un appel séparé à une fonction membre.

L’initialisation automatique est effectuée à l’aide d’une fonction membre spéciale appelée constructeur. Un constructeur est une fonction membre qui est exécutée automatiquement chaque fois qu’un objet est créé.

| | // Programme pour accepter et afficher les informations de l’employé en utilisant des constructeurs
#include
#include
using namespace std;
class emp                               // définition de la classe
{
private :                         // données privées, fonctions
int eno;
char name[10];
float sal;
public    :                        // données publiques, fonctions
emp() { ; }                  // constructeur sans arguments
emp(int teno, char tname[10], float tsal) // constructeur avec arguments
{
eno = teno;
strcpy(name, tname);
sal = tsal;
}
void getdata()
{ cin >> eno >> name >> sal;  }
void putdata()
{ cout << eno << name << sal << endl;  }
};

int main()
{
emp e1(1001, “Magic”, 6700.45);
emp e2;
e2.getdata();
e1.putdata();
e2.putdata();
return 0;
} |

L’exemple de programme ci-dessus accepte des valeurs de deux manières en utilisant des constructeurs et en utilisant des fonctions membres. Un objet, chaque fois qu’il est déclaré, est automatiquement initialisé avec les valeurs données en utilisant des constructeurs. Tandis que l’objet e2 est accessible uniquement par sa fonction membre.

Un exemple de plus pour distinguer l’utilisation du constructeur.

| | //  Les objets représentent une variable compteur
#include
using namespace std;
class counter
{
private :
int count;                                 // variable count
pubilc :
counter()           { count = 0; }    // constructeur
void inc_count() { count++; }    // incrémenter count
int get_count()   { return count; }  // retourner count
};
int main()
{
counter c1, c2;                     // définir et initialiser
cout << “\nC1 = “ << c1.get_count();       // afficher
cout << “\nC2 = “ << c2.get_count();
c1.inc_count();                            // incrémenter c1
c2.inc_count();                            // incrémenter c2
c2.inc_count();                            // incrémenter c2
cout << “\nC1 = “ << c1.get_count();       // afficher à nouveau
cout << “\nC2 = “ << c2.get_count();
return 0;
} |

| | Un constructeur a les caractéristiques suivantes.

• Initialisation automatique
• Les valeurs de retour n’étaient pas acceptées
• Même nom que la classe
• Perturbation avec le format |

10. Destructeurs

Un destructeur a le même nom que le constructeur (qui est le même que le nom de la classe) mais précédé d’un tilde :

| | // Démonstration d’un destructeur
#include
using namespace std;
class temp
{
private :
int data;
public :
temp() { data = 0;  }                    // Constructeur (même nom que la classe)
~temp() { }                                 // destructeur (même nom avec tilde)
}
int main()
{
temp t;
return 0;
} |

11. Surcharge de Constructeur

La capacité d’avoir des fonctions avec le même nom, mais un contenu différent, pour une classe apparentée. La procédure à utiliser est déterminée au moment de l’exécution par la classe de l’objet.

| | // Démonstration de la surcharge de constructeur
#include
using namespace std;
class ttime
{
private :
int hh, mm, ss;
public :
ttime() {hh = 0; mm = 0; ss = 0; } // Constructeur avec initialisation
ttime(int h, int m, int s)         // Constructeur avec 3 arguments
{
hh = h; mm = m ; ss = s;
}
ttime(int h, int m)               // Constructeur avec 2 arguments
{
hh = h; mm = m; ss = 0;
}
ttime(int h)                      // Constructeur avec 1 argument
{
hh = h; mm = 0; ss = 0;
}
~ttime() { }
void get_time()
{
cin >> hh >> mm >> ss;
}
void put_time()
{
cout << endl << hh << “  “ << mm <<”  “ <<  ss;
}
};
int main()
{
ttime t1, t2(12, 12, 12), t3(4, 5), t4(11);       // Appel des constructeurs
t1.get_time();
t1.put_time();
t2.put_time();
t3.put_time();
t4.put_time();
return 0;
} |

12. Données de Classe Statique

Si un élément de données dans une classe est défini comme statique, alors un seul tel élément est créé pour toute la classe, peu importe combien d’objets il y a. Un élément de données statique est utile lorsque tous les objets de la même classe doivent partager un élément d’information commun. Une variable membre définie comme statique a des caractéristiques similaires à une variable statique normale : elle est visible uniquement au sein de la classe, mais sa durée de vie est celle de l’ensemble du programme.

| | // Démonstration d’une donnée statique
#include
using namespace std;
class temp
{
private :
static int count;         // Un seul élément de données pour tous les objets
public :
temp() { count++; }       // incrémenter count lors de la création de l’objet
int getcount() { return count; }        // retourner count
};
int main()
{
temp t1, t2, t3;        // créer trois objets
cout << “\nCount is    “ << t1.getcount( ); // chaque objet
cout << “\nCount is    “ << t2.getcount( ); // voit le même
cout << “\nCount is    “ << t3.getcount( ); // valeur de count
return 0;
} | | | La sortie du programme ci-dessus est la suivante : (si c’est toujours statique)
Count is  3
Count is  3
Count is  3
La sortie du programme ci-dessus (si c’est automatique)
Count is 1
Count is 1
Count is 1 |

13. Fonctions Membres Statique

Comme les variables membres statiques, nous pouvons également avoir des fonctions membres statiques. Une fonction membre qui est déclarée statique a les propriétés suivantes.

| | - Une fonction statique peut avoir accès uniquement à d’autres membres statiques (fonctions ou variables) déclarés dans la même classe.

• Une fonction membre statique peut être appelée en utilisant le nom de la classe (au lieu de ses objets) comme suit :

class-name :: function-name;
|

| | // Programme pour démontrer la fonction membre statique
#include
using namespace std;
class test
{
int code ;
static int count;   // variable membre statique
public:
void setcode() { code = ++count; }
void showcode() { cout << “Numéro d’objet :” << code << endl; }
static void showcount()                     // fonction membre statique
{
cout << “Count  :” << count << endl;
}
};
int test :: count;
int main()
{
test t1, t2;
t1.setcode();
t2.setcode();
test::showcount();  // accès à la fonction statique
test t3;
t3.setcode();
test::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
return 0;
} |

14. Fonctions Amies

| | |

Les membres privés ne peuvent pas être accessibles depuis l’extérieur de la classe. C’est-à-dire qu’une fonction non-membre ne peut pas avoir accès aux données privées d’une classe. Cependant, il pourrait y avoir une situation où nous aimerions que deux classes partagent une fonction particulière. Cela est simplement réalisé par des fonctions amies.

| | Une fonction amie possède certaines caractéristiques spéciales : - Elle n’est pas dans le champ d’application de la classe à laquelle elle a été déclarée comme amie.

• Puisqu’elle n’est pas dans le champ d’application de la classe, elle ne peut pas être appelée en utilisant l’objet de la classe. Elle peut être invoquée comme une fonction normale sans l’aide d’aucun objet.
• Contrairement aux fonctions membres, elle ne peut pas accéder directement aux noms des membres et doit utiliser un nom d’objet et l’opérateur de membre par point avec chaque nom de membre.
• Elle peut être déclarée soit dans la partie publique soit dans la partie privée d’une classe sans affecter son sens.
• En général, elle a les objets comme arguments. |

| | // Programme pour démontrer la fonction amie
#include
using namespace std;
class test
{
int a;
int b;
public:
void setvalue() { a = 25; b = 40; }
friend float sum(test s);             // AMIE déclarée
};
float sum(test s)
{
return float (s.a + s.b ) / 2.0;        // s.a & s.b sont les membres privés
// de la classe test mais ils étaient accessibles
// par la fonction amie
}
int main()
{
test x;
x.setvalue();
cout << “Valeur moyenne  = “ << sum(x) << endl;
return 0;
} |

Un exemple de plus pour implémenter une fonction amie comme un pont entre deux classes.
Le programme suivant crée deux objets de deux classes et une fonction amie pour deux classes.
Dans cet exemple, la fonction amie est capable d’accéder aux membres de données des deux classes et calcule le plus grand des deux membres de données de classe.

| | #include
using namespace std;
class second;
class first
{
int a;
public:
first(int temp) { a = temp; }
friend void max(first, second);
};
class second
{
int b;
public:
second(int temp) { b = temp; }
friend void max(first, second);
};
void max(first f, second s)
{
if ( f.a > s.b )                     // les deux membres de données de first, second peuvent être
cout << “Max “<<  f.a;          // accessibles via la fonction amie max
else
cout << “Max “<< s.b;
}
int main()
{
first f(20);
second s(30);
max(f, s);
return 0;
} |

Ref : Programmation orientée objet dans Turbo C++ : Robert Lafore