P.O.O Partie 2 Suite Et Fin - 023615

Cours P.O.
O par le C++
Par Cyrille MBIA

Apprendre la programmation
Orientée Objet en C++
C++ est un puissant langage de programmation polyvalent. Il peut être utilisé pour
développer des systèmes d'exploitation, des navigateurs, des jeux, etc. C++ prend en charge
différentes méthodes de programmation telles que procédurale, orientée objet,
fonctionnelle, etc. Cela rend le C++ puissant et flexible.
Notre cours vous guidera pour apprendre la P.O.O en C++ étape par étape.
À propos de la programmation C++
✓ Langage multi-paradigme - C++ prend en charge au moins sept styles de
programmation différents. Les développeurs peuvent choisir l'un des styles.
✓ Langage à usage général - Vous pouvez utiliser C++ pour développer des jeux, des
applications de bureau, des systèmes d'exploitation, etc.
✓ Vitesse - Comme la programmation C, les performances du code C++ optimisé sont

exceptionnelles.
✓ Orienté objet - C++ vous permet de diviser des problèmes complexes en ensembles plus
petits en utilisant des objets.
Pourquoi apprendre la P.O.O en C++ ?
✓ C++ est utilisé pour développer des jeux, des applications de bureau, des systèmes
d'exploitation, des navigateurs, etc. en raison de ses performances.
✓ Après avoir appris le C++, il sera beaucoup plus facile d'apprendre d'autres langages
de programmation comme Java, Python, etc.
✓ C++ vous aide à comprendre l'architecture interne d'un ordinateur, comment

l'ordinateur stocke et récupère les informations.
Comment apprendre le C++ ?
✓ Le cours C++ de Cyrille MBIA – Le cours est détaillé étape par étape, des exemples et
des références. Commencez avec C++.
✓ Documentation officielle C++ - Peut être difficile à suivre et à comprendre pour les
débutants. Consultez la documentation officielle du C++. (Consultez la documentation
officielle)
✓ Écrire beaucoup de code de programmation C++ - La seule façon d'apprendre la

programmation est d'écrire beaucoup de code.
✓ Lire le code C++ - Rejoignez les projets open source et lisez le code d'autres
personnes.
Structure de notre cours
1 Flux de contrôles 3 Tableaux et

chaînes 5
Introduction 2 Fonctions 4 Structures

Structure de notre cours
6 Pointeurs
3
Objets et Classes
7 Héritage
01
Introduction
▪ Variables et littéraux C++
▪ Types de données C++
▪ E/S de base C++
▪ Conversion de types C++
▪ Opérateurs C++
▪ Commentaires C++
Variables, littéraux et constantes C++
Dans cette partie, nous allons découvrir les variables, les littéraux et les constantes en C++ à
l'aide d'exemples.
Variables C++
En programmation, une variable est un conteneur (zone de stockage) pour contenir des
données.
Pour indiquer la zone de stockage, chaque variable doit recevoir un nom unique (identifiant).
Par exemple, int age = 14;
Ici, age est une variable de type de données int, et nous lui avons attribué une valeur entière
14.
Remarque : Le type de données int suggère que la variable ne peut contenir que des
entiers. De même, nous pouvons utiliser le type de données double si nous devons stocker
des décimales et des exponentielles. Nous verrons en détail tous les types de données dans
la prochaine partie.
La valeur d'une variable peut être modifiée, d'où le nom de variable.

int age = 14; // age est égal à 14
age = 17; // age est égal à 17

Règles pour nommer une variable
Un nom de variable ne peut contenir que des lettres, des nombres et le trait de
soulignement _. Un nom de variable ne peut pas commencer par un nombre.
Les noms de variables ne doivent pas commencer par un caractère majuscule.
Un nom de variable ne peut pas être un mot-clé. Par exemple, int est un mot-clé utilisé pour
désigner des nombres entiers.
Un nom de variable peut commencer par un trait de soulignement. Cependant, ce n'est pas
considéré comme une bonne pratique.
Remarque : Nous devrions essayer de donner des noms significatifs aux variables. Par
exemple, first_name est un meilleur nom de variable que fn.
Littéraux C++
Les littéraux sont des données utilisées pour représenter des valeurs fixes. Ils peuvent être
utilisés directement dans le code. Par exemple : 1, 2.5, 'c' etc…
Ici, 1, 2.5 et 'c' sont des littéraux. Pourquoi? Vous ne pouvez pas attribuer des valeurs
différentes à ces termes.
Voici une liste de différents littéraux en programmation C++.
1. Entiers
Un entier est un littéral numérique (associé à des nombres) sans aucune partie fractionnaire
ou exponentielle. Il existe trois types de littéraux entiers en programmation C :
décimal (base 10)
octal (base 8)
hexadécimal (base 16)
Par exemple: Décimal : 0, -9, 22 etc., Octal : 021, 077, 033, etc., Hexadécimal : 0x7f, 0x2a,
0x521 etc. En programmation C++, l'octal commence par un 0 et l'hexadécimal par un 0x.
2. Littéraux à virgule flottante
Un littéral à virgule flottante est un littéral numérique qui a une forme fractionnaire ou une
forme d'exposant. Par exemple:
➢ -2.0
➢ 0,0000234
➢ -0.22E-5
Remarque : E-5 = 10-5

3. Caractères
Un littéral de caractère est créé en plaçant un seul caractère entre des guillemets simples.
Par exemple : 'a', 'm', 'F', '2', '}' etc…
4. Séquences d'échappement
Parfois, il est nécessaire d'utiliser des caractères qui ne peuvent pas être saisis ou qui ont
une signification particulière dans la programmation C++. Par exemple, nouvelle ligne
(entrée), tabulation, point d'interrogation, etc.
Afin d'utiliser ces caractères, des séquences d'échappement sont utilisées.

Séquences d'échappement Caractères
\b Retour arrière
\f Flux de formulaire
\n Nouvelle ligne
\r Revenir
\t Tabulation horizontale
\v Tabulation Verticale
\\ Backslash
\' guillemet simple
\" guillemets doubles
\? Point d'interrogation
\0 Caractère nul
5. Littéraux de chaîne
Un littéral de chaîne est une séquence de caractères entre guillemets doubles. Par exemple :
"bonne" constante de chaîne
"" constante de chaîne nulle
" " constante de chaîne de un espace blanc
constante de chaîne "x" ayant un seul caractère
"La Terre est ronde\n" imprime une chaîne avec une nouvelle ligne
Constantes C++
En C++, nous pouvons créer des variables dont la valeur ne peut pas être modifiée. Pour cela,
nous utilisons le mot-clé const. Voici un exemple :
const int LIGHT_SPEED = 299792458;
LIGHT_SPEED = 2500 // Error! LIGHT_SPEED is a constant.
Ici, nous avons utilisé le mot-clé const pour déclarer une constante nommée LIGHT_SPEED.
Si nous essayons de modifier la valeur de LIGHT_SPEED, nous obtiendrons une erreur.
Une constante peut également être créée à l'aide de la directive de préprocesseur #define.
Nous l'apprendrons en détail dans la partie sur les macros C++.
Types de données C++
Dans cette partie, nous allons découvrir les types de données de base tels que int, float,
char, etc. en programmation C++ à l'aide d'exemples.
En C++, les types de données sont des déclarations de variables. Cela détermine le type et la
taille des données associées aux variables. Par exemple,
int age = 13;
Ici, l'âge est une variable de type int. Cela signifie que la variable ne peut stocker que des
entiers de 2 ou 4 octets.
Types de données fondamentaux C++
Le tableau ci-dessous présente les types de données fondamentaux, leur signification et

leurs tailles (en octets) :
Type de données Sens Taille (en octets)
int Entier 2 ou 4
float Virgule flotante 4
double Double virgule flotante 8
char Caractère 1
wchar_t Caractère large 2
bool Booléen 1
void Vide 0
Modificateurs de type C++
Nous pouvons encore modifier certains des types de données fondamentaux en utilisant des
modificateurs de type. Il existe 4 modificateurs de type en C++. Ils sont:
• signed
• unsigned
• short
• Long
Nous pouvons modifier les types de données suivants avec les modificateurs ci-dessus :
• int
• double
• char
Liste des types de données modifiés C++
Source :
https://www.tutorialspoint.com
/cplusplus/cpp_modifier_type
s.htm
Le 20 Dec. 2007 A 14h23
Entrée/sortie de base C++
Dans cette partie, nous apprendrons à utiliser l'objet cin pour prendre les entrées de
l'utilisateur et l'objet cout pour afficher les sorties à l'utilisateur à l'aide d'exemples.
Sortie C++
En C++, cout envoie une sortie formatée aux périphériques de sortie standard, tels que
l'écran. Nous utilisons l'objet cout avec l'opérateur << pour afficher la sortie.
#include <iostream>
using namespace std;
int main() {
// imprime la chaîne entre guillemets doubles
cout << "This is C++ Programming";
return 0;
}
Comment fonctionne ce programme ?
Nous incluons d'abord le fichier d'en-tête iostream qui nous permet d'afficher la sortie.
L'objet cout est défini dans l'espace de noms std. Pour utiliser l'espace de noms std, nous
avons utilisé l'espace de noms using namespace std ; déclaration.
Chaque programme C++ commence par la fonction main(). L'exécution du code commence
au début de la fonction main().
cout est un objet qui imprime la chaîne entre guillemets " ". Il est suivi de l'opérateur <<.
return 0 ; est le "état de sortie" de la fonction main(). Le programme se termine par cette
instruction, cependant, cette instruction n'est pas obligatoire.
Remarque : si nous n'incluons pas la déclaration using namespace std;, nous devons utiliser
std::cout au lieu de cout.
C'est la méthode préférée car l'utilisation de l'espace de noms std peut créer des problèmes
potentiels.
Cependant, nous avons utilisé l'espace de noms std dans ce cours afin de rendre les codes
plus lisibles.
#include <iostream>
int main() {
// imprime la chaîne entre guillemets doubles
std::cout << "This is C++ Programming";
return 0;
}
Exemple 2 : Sortie de nombres et de caractères
Pour imprimer les nombres et les variables de caractères, nous utilisons le même objet
cout mais sans utiliser de guillemets.
#include <iostream>
int main() {
int num1 = 70;
double num2 = 256.783;
char ch = 'A';
cout << num1 << endl; // print integer
cout << num2 << endl; // print double
cout << "character: " << ch << endl; // print char
return 0;
}
Remarques:
Le manipulateur endl est utilisé pour insérer une nouvelle ligne. C'est pourquoi chaque sortie
est affichée dans une nouvelle ligne.
L'opérateur << peut être utilisé plusieurs fois si nous voulons imprimer différentes variables,
chaînes, etc. dans une seule instruction. Par exemple:
cout << "character: " << ch << endl;

Entrée C++
En C++, cin prend une entrée formatée à partir de périphériques d'entrée standard tels que le
clavier. Nous utilisons l'objet cin avec l'opérateur >> pour la saisie.
#include <iostream>
int main() {
int num;
cout << "Enter an integer: ";
cin >> num; // Taking input
cout << "The number is: " << num;
return 0; }
C++ prenant plusieurs entrées
#include <iostream>
int main() {
char a;
int num;
cout << "Enter a character and an integer: ";
cin >> a >> num;
cout << "Character: " << a << endl;
cout << "Number: " << num;
return 0;
}
Conversion de types C++
C++ nous permet de convertir des données d'un type en celles d'un autre. C'est ce qu'on
appelle la conversion de type.
Il existe deux types de conversion de type en C++.
✓ Conversion implicite
✓ Conversion explicite (également connue sous le nom de casting)

Opérateurs C++
Les opérateurs sont des symboles qui effectuent des opérations sur des variables et des
valeurs. Par exemple, + est un opérateur utilisé pour l'addition, tandis que - est un opérateur
utilisé pour la soustraction. Les opérateurs en C++ peuvent être classés en 6 types :
✓ Opérateurs arithmétiques
✓ Opérateurs d'affectation
✓ Opérateurs relationnels
✓ Opérateurs logiques
✓ Opérateurs au niveau du bit
✓ Autres opérateurs
02
Les flux de contrôles
▪ if...else
▪ for
▪ do...while
▪ break
▪ continue
▪ Switch
▪ goto
if, if...else et if...else imbriqué
Dans cette partie, nous allons découvrir l'instruction if...else pour créer des programmes de
prise de décision à l'aide d'exemples.
En programmation informatique, nous utilisons l'instruction if pour exécuter un code de bloc

uniquement lorsqu'une certaine condition est remplie.
Par exemple, attribuer des notes (A, B, C) en fonction des notes obtenues par un élève.
si le pourcentage est supérieur à 90, attribuez la note A
si le pourcentage est supérieur à 75, attribuez la note B
si le pourcentage est supérieur à 65, attribuez la note C

Il existe trois formes d'instructions if...else en C++.
Déclaration if
Déclaration if... else
Instruction if... else if... else

Instruction if
La syntaxe de l'instruction if est :
if (condition) {
// corps de l'instruction if
L'instruction if évalue la condition entre parenthèses ( ).
Si la condition est vraie, le code à l'intérieur du corps de if est exécuté.
Si la condition est fausse, le code à l'intérieur du corps de if est ignoré.
Remarque : Le code à l'intérieur de { } est le corps de l'instruction if.

If,,,else
L'instruction if peut avoir une clause else facultative. Sa syntaxe est :
if (condition) {
// bloc de code si la condition est vraie
else {
// bloc de code si la condition est fausse
}
L'instruction if..else évalue la condition à l'intérieur de la parenthèse.
➢ Si la condition est vraie, le code à l'intérieur du corps de if est exécuté, le code à

l'intérieur du corps de else est ignoré de l'exécution
➢ Si la condition est fausse, le code à l'intérieur du corps de else est exécuté, le code à
l'intérieur du corps de if est ignoré de l'exécution
Boucle for
Dans cette partie, nous allons découvrir la boucle for et son fonctionnement à l'aide de
quelques exemples.
En programmation informatique, les boucles sont utilisées pour répéter un bloc de code.
Par exemple, disons que nous voulons afficher un message 100 fois. Ensuite, au lieu d'écrire
l'instruction print 100 fois, nous pouvons utiliser une boucle.
C'était juste un exemple simple; nous pouvons atteindre beaucoup plus d'efficacité dans nos
programmes en utilisant efficacement les boucles.
Il existe 3 types de boucles en C++. For, while, do…while

For
La syntaxe de la boucle for est :
for (initialisation; condition; mise à jour) {
// corps
Ici, initialisation - initialise les variables et n'est exécuté qu'une seule fois
condition - si vrai, le corps de la boucle for est exécuté
si faux, la boucle for est terminée
Mise à jour - met à jour la valeur des variables initialisées et vérifie à nouveau la condition
While
La syntaxe de la boucle while est :
while (condition) {
// corps
Ici, Une boucle while évalue la condition. Si la condition est vraie, le code à l'intérieur de la
boucle while est exécuté. La condition est à nouveau évaluée.
Ce processus se poursuit jusqu'à ce que la condition soit fausse.
Lorsque la condition est évaluée à faux, la boucle se termine.

Do…While
La boucle do...while est une variante de la boucle while avec une différence importante : le
corps de la boucle do...while est exécuté une fois avant que la condition ne soit vérifiée.
Sa syntaxe est :
do {
// corps;
}while (condition);
Ici, Le corps de la boucle est exécuté dans un premier temps. Ensuite, la condition est
évaluée. Si la condition est vraie, le corps de la boucle à l'intérieur de l'instruction do est à
nouveau exécuté. La condition est à nouveau évaluée. Si la condition est vraie, le corps de la
boucle à l'intérieur de l'instruction do est à nouveau exécuté. Ce processus se poursuit
jusqu'à ce que la condition soit fausse. Puis la boucle s'arrête.
Break
En C++, l'instruction break termine la boucle lorsqu'elle est rencontrée.
La syntaxe de l'instruction break est : break;

continue
En programmation informatique, l'instruction continue est utilisée pour ignorer l'itération en
cours de la boucle et le contrôle du programme passe à l'itération suivante.
La syntaxe de l'instruction continue est : continue;

Switch…case
L'instruction switch nous permet d'exécuter un bloc de code parmi de nombreuses
alternatives.
La syntaxe de l'instruction switch en C++ est :

Fonctions
Dans cette partie, nous allons découvrir les fonctions C++ et les expressions de fonctions à
l'aide d'exemples.
Une fonction est un bloc de code qui exécute une tâche spécifique.
Supposons que nous ayons besoin de créer un programme pour créer un cercle et le
colorier. Nous pouvons créer deux fonctions pour résoudre ce problème :
✓ une fonction pour dessiner le cercle
✓ une fonction pour colorer le cercle

Fonctions
Diviser un problème complexe en petits morceaux rend notre programme facile à
comprendre et réutilisable.
Il existe deux types de fonction :
✓ Fonctions de bibliothèque standard : prédéfinies en C++
✓ Fonction définie par l'utilisateur : créée par les utilisateurs
Dans ce cours, nous nous concentrerons principalement sur les fonctions définies par
l'utilisateur.
Fonctions
Fonction définie par l'utilisateur C++
C++ permet au programmeur de définir sa propre fonction.
Une fonction définie par l'utilisateur regroupe un code pour effectuer une tâche spécifique et
ce groupe de code reçoit un nom (identifiant).
Lorsque la fonction est invoquée depuis n'importe quelle partie du programme, tout exécute
les codes définis dans le corps de la fonction.
Déclaration de fonction C++
La syntaxe pour déclarer une fonction est :
typeRetour nomFonction (parametre1, parametre2,...) {
// corps
}
Surcharge de fonction C++
En C++, deux fonctions peuvent avoir le même nom si le nombre et/ou le type d'arguments
passés sont différents.
Ces fonctions ayant le même nom mais des arguments différents sont appelées fonctions
surchargées. Par exemple:
// même nom arguments différents
int test() { }
int test(int a) { }
float test(double a) { }
int test(int a, double b) { }

Ici, les 4 fonctions sont des fonctions surchargées.
Notez que les types de retour de toutes ces 4 fonctions ne sont pas les mêmes. Les
fonctions surchargées peuvent avoir ou non des types de retour différents, mais elles
doivent avoir des arguments différents. Par exemple,
// Erreur
int test(int a) { }
double test(int b){ }
Ici, les deux fonctions ont le même nom, le même type et le même nombre d'arguments. Par conséquent, le
compilateur renverra une erreur.
Variable Statique locale
Le mot-clé static est utilisé pour spécifier une variable statique. Par exemple:
int main()
static float a;
... .. ...
}
Une variable locale statique n'existe qu'à l'intérieur d'une fonction où elle est déclarée
(similaire à une variable locale) mais sa durée de vie commence lorsque la fonction est
appelée et se termine uniquement lorsque le programme se termine.
le différence principale entre variable locale et variable statique est que, la valeur de la
variable statique persiste à la fin du programme.
Les tableaux
En C++, un tableau est une variable qui peut stocker plusieurs valeurs du même type. Par
exemple,
Supposons qu'une classe compte 27 élèves et que nous ayons besoin de stocker les notes
de chacun d'eux. Au lieu de créer 27 variables distinctes, nous pouvons simplement créer un
tableau : double grade[27];
Ici, grade est un tableau pouvant contenir un maximum de 27 éléments de type double.
En C++, la taille et le type des tableaux ne peuvent pas être modifiés après sa déclaration.
Accès aux éléments d’un tableau C++
En C++, chaque élément d'un tableau est associé à un nombre. Le nombre est appelé index de tableau. Nous
pouvons accéder aux éléments d'un tableau en utilisant ces indices.
Les tableaux
Quelques éléments à retenir :
Les index du tableau commencent par 0. Ce qui signifie que x[0] est le premier élément
stocké à l'index 0.
Si la taille d'un tableau est n, le dernier élément est stocké à l'indice (n-1). Dans cet exemple,
x[5] est le dernier élément.
Les éléments d'un tableau ont des adresses consécutives. Par exemple, supposons que
l'adresse de départ de x[0] est 2120d. Ensuite, l'adresse de l'élément suivant x[1] sera 2124d,
l'adresse de x[2] sera 2128d et ainsi de suite.
Ici, la taille de chaque élément est augmentée de 4. C'est parce que la taille de int est de 4
octets.
Les tableaux
Initialisation du tableau C++
En C++, il est possible d'initialiser un tableau lors de la déclaration. Par exemple,
Une autre méthode pour initialiser le tableau lors de la déclaration :
Ici, nous n'avons pas mentionné la taille du tableau. Dans de tels cas, le compilateur calcule
automatiquement la taille.
Les tableaux
Tableau C++ avec des membres vides
En C++, si un tableau a une taille n, nous pouvons stocker jusqu'à n nombre d'éléments dans le tableau.
Cependant, que se passera-t-il si nous stockons moins de n éléments
Par exemple,
Ici, le tableau x a une taille de 6. Cependant, nous l'avons initialisé avec seulement 3 éléments.
Dans de tels cas, le compilateur attribue des valeurs aléatoires aux emplacements restants. Souvent, cette
valeur aléatoire est simplement 0.
Tableaux multidimensionnels
En C++, nous pouvons créer un tableau d'un tableau, appelé tableau multidimensionnel. Par exemple:
int x[3][4];
Ici, x est un tableau à deux dimensions. Il peut contenir un maximum de 12 éléments.
Nous pouvons considérer ce tableau comme un tableau avec 3 lignes et chaque ligne a 4 colonnes comme
indiqué ci-dessous.
Les tableaux tridimensionnels fonctionnent également de la même manière. Par exemple: float x[2][4][3];
Ce tableau x peut contenir un maximum de 24 éléments.
Nous pouvons connaître le nombre total d'éléments du tableau en multipliant simplement ses dimensions :
Initialisation de tableau multidimensionnel
Comme un tableau normal, nous pouvons initialiser un tableau multidimensionnel de plusieurs manières.
1. Initialisation du tableau à deux dimensions
int test[2][3] = {2, 4, 5, 9, 0, 19};

La méthode ci-dessus n'est pas préférée. Une meilleure façon d'initialiser ce tableau avec les mêmes
éléments de tableau est donnée ci-dessous :
int test[2][3] = { {2, 4, 5}, {9, 0, 19}};
Ce tableau a 2 lignes et 3 colonnes, c'est pourquoi nous avons deux lignes d'éléments avec 3 éléments
chacune.
2. Initialisation du tableau tridimensionnel
int test[2][3][4] = {3, 4, 2, 3, 0, -3, 9, 11, 23, 12, 23,
2, 13, 4, 56, 3, 5, 9, 3, 5, 5, 1, 4, 9};
Ce n'est pas une bonne façon d'initialiser un tableau à trois dimensions. Une meilleure façon d'initialiser ce
tableau est :
int test[2][3][4] = {
{ {3, 4, 2, 3}, {0, -3, 9, 11}, {23, 12, 23, 2} },
{ {13, 4, 56, 3}, {5, 9, 3, 5}, {5, 1, 4, 9} }
};
Passer un tableau à une fonction en C++
En C++, nous pouvons passer des tableaux en argument à une fonction. Et, nous pouvons également
retourner des tableaux à partir d'une fonction.
Syntaxe pour passer des tableaux en tant que paramètres de fonction
La syntaxe pour passer un tableau à une fonction est :

Passer un tableau à une fonction en C++
Exemple 1 : passer un tableau à une dimension à une fonction
Les chaînes
La chaîne est une collection de caractères. Il existe deux types de chaînes couramment utilisées dans le
langage de programmation C++ :
✓ Les chaînes qui sont des objets de la classe de chaînes (la classe de chaînes de la bibliothèque standard
C++)
✓ C-strings (C-style Strings)
C-strings
En programmation C, la collection de caractères est stockée sous forme de tableaux. Ceci est également pris
en charge dans la programmation C++. C'est pourquoi on l'appelle C-strings.
Les chaînes C sont des tableaux de type char terminés par un caractère nul, c'est-à-dire \0 (la valeur ASCII
du caractère nul est 0).
Les chaînes
Comment définir un C-string ?
char str[] = "C++";
Dans le code ci-dessus, str est une chaîne et contient 4 caractères.
Bien que "C++" ait 3 caractères, le caractère nul \0 est automatiquement ajouté à la fin de la chaîne.
Objet chaîne
En C++, vous pouvez également créer un objet chaîne pour contenir des chaînes.
Contrairement à l'utilisation de tableaux de caractères, les objets chaîne n'ont pas de longueur fixe et
peuvent être étendus selon vos besoins.
Structures
La structure est une collection de variables de différents types de données sous un même nom. Il est
similaire à une classe en ce sens que les deux contiennent une collection de données de différents types de
données.
Par exemple : Vous souhaitez stocker des informations sur une personne : son nom, son numéro de
nationalité et son salaire. Vous pouvez facilement créer différentes variables nom, citNo, salaire pour stocker
ces informations séparément.
Cependant, à l'avenir, vous souhaiterez stocker des informations sur plusieurs personnes. Maintenant, vous
devez créer différentes variables pour chaque information par personne : nom1, citNo1, salaire1, nom2,
citNo2, salaire2
Structures
Vous pouvez facilement visualiser à quel point le code serait gros et désordonné. De plus, étant donné
qu'aucune relation entre les variables (informations) n'existerait, cela va être une tâche ardue.
Une meilleure approche serait d'avoir une collection de toutes les informations connexes sous un seul nom
de personne, et de l'utiliser pour chaque personne. Maintenant, le code semble beaucoup plus propre, lisible
et efficace également.
Cette collection de toutes les informations connexes sous un seul nom Person est une structure.
Comment déclarer une structure en programmation C++ ?
Le mot clé struct définit un type de structure suivi d'un identifiant (nom de la structure).
Ensuite, à l'intérieur des accolades, vous pouvez déclarer un ou plusieurs membres (déclarer des variables à
l'intérieur des accolades) de cette structure. Par exemple:
Structures
struct Person
char name[50];
int age;
float salary;
};
Ici, une structure personne est définie qui a trois membres : nom, âge et salaire
Structures
Lorsqu'une structure est créée, aucune mémoire n'est allouée.
La définition de la structure n'est que le modèle pour la création des variables. Vous pouvez l'imaginer
comme un type de données. Lorsque vous définissez un entier comme ci-après : int foo;
L'entier spécifie que la variable foo ne peut contenir que l'élément entier. De même, la définition de structure
spécifie uniquement la propriété d'une variable de structure lorsqu'elle est définie.
Remarque : N'oubliez pas de terminer la déclaration par un point-virgule (;)
Comment définir une variable de structure ?
Une fois que vous déclarez une structure Person comme ci-dessous. Vous pouvez définir une variable de
structure comme :
Person bill;
Structures
Ici, une variable de structure bill est définie qui est de type structure Person.
Lorsque la variable de structure est définie, alors seulement la mémoire requise est allouée par le
compilateur.
Considérant que vous avez un système 32 bits ou 64 bits, la mémoire de float est de 4 octets, la mémoire de
int est de 4 octets et la mémoire de char est de 1 octet.
Par conséquent, 58 octets de mémoire sont alloués à la variable de structure bill.

Structures
Comment accéder aux membres d'une structure ?
Les membres de la variable de structure sont accessibles à l'aide d'un opérateur point (.).
Supposons que vous souhaitiez accéder à la variable d'âge de la structure et lui attribuer 50. Vous pouvez
effectuer cette tâche en utilisant le code suivant ci-dessous : bill.age = 50;
Structures
06
La P.O.O en C++
Qu'est-ce que la POO ?
POO signifie Programmation Orientée Objet.
La programmation procédurale consiste à écrire des procédures ou des fonctions qui effectuent des
opérations sur les données, tandis que la programmation orientée objet consiste à créer des objets qui
contiennent à la fois des données et des fonctions.
La programmation orientée objet présente plusieurs avantages par rapport à la programmation procédurale :
La POO est plus rapide et plus facile à exécuter
La POO fournit une structure claire pour les programmes
La POO aide à garder le code C++ SEC "Ne vous répétez pas", et facilite la maintenance, la modification et le
débogage du code
La POO permet de créer des applications entièrement réutilisables avec moins de code et un temps de
développement plus court
Qu'est-ce que la POO ?
Dans les parties précédentes, nous avons découvert les fonctions et les variables. Parfois, il est souhaitable
de mettre les fonctions et les données associées au même endroit afin qu'il soit logique et plus facile de
travailler avec.
Supposons que nous ayons besoin de stocker la longueur, la largeur et la hauteur d'une pièce rectangulaire
et de calculer sa superficie et son volume.
Pour gérer cette tâche, nous pouvons créer trois variables, par exemple, la longueur, la largeur et la hauteur
avec les fonctions calculateArea() et calculateVolume().
Cependant, en C++, plutôt que de créer des variables et des fonctions séparées, nous pouvons également
encapsuler ces données et fonctions liées en un seul endroit (en créant des objets). Ce paradigme de
programmation est connu sous le nom de programmation orientée objet.
Mais avant de pouvoir créer des objets et les utiliser en C++, nous devons d'abord nous familiariser avec les
classes.
Classe C++
Une classe est un modèle pour l'objet.
Nous pouvons considérer une classe comme un croquis (prototype) d'une maison. Il contient tous les détails
sur les sols, les portes, les fenêtres, etc. Sur la base de ces descriptions, nous construisons la maison. La
maison est l'objet.
Créer une classe
Une classe est définie en C++ à l'aide du mot-clé class suivi du nom de la classe.
Le corps de la classe est défini à l'intérieur des accolades et terminé par un point-virgule à la fin.
Classe C++
Par exemple,
Ici, nous avons défini une classe nommée Room.
Les variables length, breadth et height déclarées à l'intérieur de la classe sont appelées membres de
données. Et, les fonctions calculateArea() et calculateVolume() sont appelées fonctions membres d'une
classe ou méthodes.
Objets C++
Lorsqu'une classe est définie, seule la spécification de l'objet est définie ; aucune mémoire ou stockage n'est
alloué.
Pour utiliser les données et les fonctions d'accès définies dans la classe, nous devons créer des objets.
Syntaxe pour définir un objet en C++
className objectVariableName;
Nous pouvons créer des objets de classe Room (définis dans l'exemple ci-dessus) comme suit :
Objets C++
Ici, deux objets room1 et room2 de la classe Room sont créés dans sampleFunction(). De même, les objets
room3 et room4 sont créés dans main().
Comme nous pouvons le voir, nous pouvons créer des objets d'une classe dans n'importe quelle fonction du
programme. Nous pouvons également créer des objets d'une classe au sein de la classe elle-même, ou dans
d'autres classes.
De plus, nous pouvons créer autant d'objets que nous le souhaitons à partir d'une même classe.
Accès aux données membres et fonctions membres
Nous pouvons accéder aux données membres et aux fonctions membres d'une classe en utilisant un
opérateur (point). Par exemple, room2.calculateArea();
Objets C++
Cela appellera la fonction calculateArea() à l'intérieur de la classe Room pour l'objet room2.
De même, les membres de données sont accessibles en tant que : room1.length = 5.5;
Dans ce cas, il initialise la variable length de room1 à 5.5.
Exemple 1 : Objet et classe en programmation C++ (diapo suivante)

Objets C++
Objets C++
Dans ce programme, nous avons utilisé la classe Room et son objet room1 pour calculer la surface et le
volume d'une pièce.
Dans main(), nous avons attribué les valeurs de length, de breadth et de height avec le code :
Objets C++
Nous avons ensuite appelé les fonctions calculateArea() et calculateVolume() pour effectuer les calculs
nécessaires.
Notez l'utilisation du mot-clé public dans le programme. Cela signifie que les membres sont publics et
peuvent être consultés n'importe où à partir du programme.
Selon nos besoins, nous pouvons également créer des membres privés en utilisant le mot-clé private. Les
membres privés d'une classe ne sont accessibles qu'à partir de la classe. Par exemple,
Objets C++
Ici, a et function1() sont privés. Ils ne sont donc pas accessibles depuis l'extérieur de la classe.
En revanche, b et function2() sont accessibles de n'importe où dans le programme.
Exemple 2 : Utilisation de public et private dans la classe C++

Objets C++
L'exemple ci-dessus est presque identique au premier exemple, sauf que les variables de classe sont
maintenant privées.
Puisque les variables sont maintenant privées, nous ne pouvons pas y accéder directement depuis main().
Par conséquent, l'utilisation du code suivant serait invalide :
Au lieu de cela, nous utilisons la fonction publique initData() pour initialiser les variables privées via les
paramètres de fonction double len, double brth et double hgt.
Constructeurs
Un constructeur est un type spécial de fonction membre qui est appelé automatiquement lorsqu'un objet est
créé.
En C++, un constructeur a le même nom que celui de la classe et il n'a pas de type de retour. Par exemple,
Ici, la fonction Wall() est un constructeur de la classe Wall. Notez que le constructeur a le même nom que la
classe, n'a pas de type de retour, et est public
Constructeurs
Constructeur par défaut
Un constructeur sans paramètres est appelé constructeur par défaut. Dans l'exemple ci-dessus, Wall() est
un constructeur par défaut.
Constructeurs
Ici, lorsque l'objet wall1 est créé, le constructeur Wall() est appelé. Cela définit la variable de length de
l'objet à 5,5.
Remarque : si nous n'avons pas défini de constructeur dans notre classe, le compilateur C++ créera
automatiquement un constructeur par défaut avec un code vide et aucun paramètre.
Constructeur paramétré
En C++, un constructeur avec des paramètres est appelé constructeur paramétré. Il s'agit de la méthode
préférée pour initialiser les données des membres.
Constructeurs
Exemple 2 : constructeur paramétré C++
Constructeurs
Ici, nous avons créé un constructeur paramétré Wall() qui a 2 paramètres : double len et double hgt. Les
valeurs contenues dans ces paramètres sont utilisées pour initialiser les variables membres length et height.
Lorsque nous créons un objet de la classe Wall, nous passons les valeurs des variables membres en
arguments. Le code pour cela est :
Wall wall1(10.5, 8.6);
Wall wall2(8.5, 6.3);
Avec les variables membres ainsi initialisées, nous pouvons maintenant calculer l'aire du mur avec la fonction
calculateArea().
Constructeurs
Copier le constructeur
Le constructeur de copie en C++ est utilisé pour copier les données d'un objet vers un autre.
Constructeurs
Dans ce programme, nous avons utilisé un constructeur de copie pour copier le contenu d'un objet de la
classe Wall dans un autre. Le code du constructeur de copie est :
Wall(Wall &obj) {
length = obj.length;
height = obj.height;
Notez que le paramètre de ce constructeur a l'adresse d'un objet de la classe Wall.
Nous affectons ensuite les valeurs des variables de l'objet obj aux variables correspondantes de l'objet
appelant le constructeur de copie. C'est ainsi que le contenu de l'objet est copié.
Dans main(), nous créons ensuite deux objets wall1 et wall2 puis copions le contenu de wall1 vers wall2 :
Constructeurs
// copier le contenu de wall1 à wall2
Wall wall2 = wall1;
Ici, l'objet wall2 appelle son constructeur de copie en passant l'adresse de l'objet wall1 comme argument,
c'est-à-dire &obj = &wall1.
Remarque : Un constructeur est principalement utilisé pour initialiser des objets. Ils sont également utilisés
pour exécuter un code par défaut lors de la création d'un objet.
Destructeur C++
Un destructeur fonctionne à l'opposé du constructeur ; il détruit les objets des classes. Il ne peut être défini
qu'une seule fois dans une classe. Comme les constructeurs, il est invoqué automatiquement.
Un destructeur se définit comme un constructeur. Il doit avoir le même nom que la classe. Mais il est préfixé
d'un signe tilde (~).
Remarque : le destructeur C++ ne peut pas avoir de paramètres. De plus, les modificateurs ne peuvent pas
être appliqués sur les destructeurs.
C++ pointeur this
En programmation C++, il s'agit d'un mot-clé qui fait référence à l'instance actuelle de la classe. Il peut y avoir
3 utilisations principales de ce mot-clé en C++.
✓ Il peut être utilisé pour passer l'objet courant en tant que paramètre à une autre méthode.
✓ Il peut être utilisé pour faire référence à la variable d'instance de classe actuelle.
✓ Il peut être utilisé pour déclarer des indexeurs.

C++ pointeur this
Comment passer et retourner un
objet à partir des fonctions C++ ?
En programmation C++, nous pouvons passer des objets à une fonction de la même manière que passer des
arguments normaux.
Exemple 1 : C++ passe des objets à la fonction (diapo suivante)

Ici, nous avons passé deux objets Student student1 et student2 comme arguments à la fonction
calculateAverage().
Surcharge d'opérateur C++
En C++, nous pouvons changer la façon dont les opérateurs fonctionnent pour les types définis par
l'utilisateur comme les objets et les structures. C'est ce qu'on appelle la surcharge d'opérateur. Par exemple,
Supposons que nous ayons créé trois objets c1, c2 et que nous résultions d'une classe nommée Complex
qui représente des nombres complexes.
Étant donné que la surcharge d'opérateurs nous permet de modifier le fonctionnement des opérateurs, nous
pouvons redéfinir le fonctionnement de l'opérateur + et l'utiliser pour ajouter les nombres complexes de c1 et
c2 en écrivant le code suivant : result = c1 + c2;
au lieu de quelque chose comme result = c1.addNumbers(c2);
Cela rend notre code intuitif et facile à comprendre.

Remarque : Nous ne pouvons pas utiliser la surcharge d'opérateurs pour les types de données
fondamentaux tels que int, float, char, etc.
Syntaxe pour la surcharge d'opérateur C++
Pour surcharger un opérateur, nous utilisons une fonction d'opérateur spéciale. Nous définissons la fonction
à l'intérieur de la classe ou de la structure dont nous voulons que l'opérateur surchargé travaille avec les
objets/variables.
Ici, returnType est le type de retour de la fonction.
opérator est un mot-clé.
symbol est l'opérateur que nous voulons surcharger. Comme : +, <, -, ++, etc.
arguments sont les arguments passés à la fonction.

Surcharge d'opérateurs dans les opérateurs unaires
Les opérateurs unaires opèrent sur un seul opérande. L'opérateur d'incrémentation ++ et l'opérateur de
décrémentation -- sont des exemples d'opérateurs unaires.
Exemple 1 : Surcharge de l'opérateur ++ (opérateur unaire)
Ici, lorsque nous utilisons ++count1;, l'opérateur void ++() est appelé. Cela augmente l'attribut value pour
l'objet count1de 1.
Remarque : lorsque nous surchargeons les opérateurs, nous pouvons l'utiliser pour travailler comme bon
nous semble. Par exemple, nous aurions pu utiliser ++ pour augmenter la valeur de 100.
Cependant, cela rend notre code confus et difficile à comprendre. C'est notre travail en tant que
programmeur d'utiliser la surcharge opérateur correctement et de manière cohérente et intuitive.
Ici, lorsque nous utilisons ++count1;, l'opérateur void ++() est appelé. Cela augmente l'attribut value pour
l'objet count1de 1.
Remarque : lorsque nous surchargeons les opérateurs, nous pouvons l'utiliser pour travailler comme bon
nous semble. Par exemple, nous aurions pu utiliser ++ pour augmenter la valeur de 100.
Cependant, cela rend notre code confus et difficile à comprendre. C'est notre travail en tant que
programmeur d'utiliser la surcharge opérateur correctement et de manière cohérente et intuitive.
L'exemple ci-dessus ne fonctionne que lorsque ++ est utilisé comme préfixe. Pour faire fonctionner ++ comme
suffixe, nous utilisons cette syntaxe.
Remarquez l'int à l'intérieur des parenthèses. C'est la syntaxe utilisée pour utiliser les opérateurs unaires
comme suffixe ; ce n'est pas un paramètre de fonction.
Exemple 2 : surcharge de l'opérateur ++ (opérateur unaire)
L'exemple 2 fonctionne lorsque ++ est utilisé à la fois comme préfixe et comme suffixe.
Cependant, cela ne fonctionne pas si nous essayons de faire quelque chose comme
ceci :
C'est parce que le type de retour de notre fonction d'opérateur est void. Nous pouvons
résoudre ce problème en faisant de Count le type de retour de la fonction opérateur.
Les pointeurs
En C++, les pointeurs sont des variables qui stockent les adresses mémoire d'autres variables.
Adresse en C++
Si nous avons une variable var dans notre programme, &var nous donnera son adresse dans la mémoire.
Voici comment déclarer des pointeurs.

Les pointeurs
Ici, nous avons déclaré un pointeur pointVar de type int.
Nous pouvons également déclarer des pointeurs de la manière suivante.

Pointeurs et tableaux C++
En C++, les pointeurs sont des variables qui contiennent les adresses d'autres variables. Non seulement un
pointeur peut stocker l'adresse d'une seule variable, il peut également stocker l'adresse des cellules d'un
tableau.
Considérez cet exemple :

Pointeurs et tableaux C++
Ici, ptr est une variable pointeur tandis que arr est un tableau int. Le code ptr = arr; stocke l'adresse du
premier élément du tableau dans la variable ptr.
Notez que nous avons utilisé arr au lieu de &arr[0]. C'est parce que les deux sont identiques. Ainsi, le code ci-
dessous est le même que le code ci-dessus.
Les adresses des autres éléments du tableau sont données par &arr[1], &arr[2], &arr[3] et &arr[4].
Appel C++ par référence : utilisation
de pointeurs
Nous avons appris à passer des arguments à une fonction. Cette méthode utilisée est appelée passage par
valeur car la valeur réelle est passée.
Cependant, il existe une autre façon de passer des arguments à une fonction où les valeurs réelles des
arguments ne sont pas transmises. Au lieu de cela, la référence aux valeurs est transmise.
Appel C++ par référence : utilisation
de pointeurs
Exemple 1 : Passage par référence sans pointeurs
Exemple 2 : Passage par référence à l'aide de pointeurs

Héritage C++
L'héritage est l'une des fonctionnalités clés de la programmation orientée objet en C++. Il nous permet de
créer une nouvelle classe (classe dérivée) à partir d'une classe existante (classe de base).
La classe dérivée hérite des fonctionnalités de la classe de base et peut avoir ses propres fonctionnalités
supplémentaires. Par exemple,
Héritage C++
L'héritage est l'une des fonctionnalités clés de la programmation orientée objet en C++. Il nous permet de
créer une nouvelle classe (classe dérivée) à partir d'une classe existante (classe de base).
La classe dérivée hérite des fonctionnalités de la classe de base et peut avoir ses propres fonctionnalités
supplémentaires. Par exemple,
Ici, la classe Dog est dérivée de la classe Animal. Puisque Dog est dérivé d'Animal, les membres d'Animal
sont accessibles à Dog.
Notez l'utilisation du mot-clé public lors de l'héritage de Dog d'Animal.

Héritage C++
On peut aussi utiliser les mots-clés private et protected au lieu de public. Nous découvrirons les différences
entre l'utilisation de private, public et protected plus tard dans ce didacticiel.
Exemple 1 : exemple simple d'héritage C++

Héritage C++
Ici, dog1 (l'objet de la classe dérivée Dog) peut accéder aux membres de la classe de base Animal. C'est
parce que Dog est hérité d'Animal.
Membres protégés
Le modificateur d'accès protected est particulièrement pertinent lorsqu'il s'agit d'héritage C++.
Comme les membres privés, les membres protégés sont inaccessibles en dehors de la classe. Cependant,
elles sont accessibles par les classes dérivées et les classes/fonctions amies.
Nous avons besoin de membres protégés si nous voulons masquer les données d'une classe, tout en
souhaitant que ces données soient héritées par ses classes dérivées.
Héritage C++
Modificateurs d'accès C++
Les modificateurs d'accès de C++ sont public, private et protected.
L'une des principales caractéristiques des langages de programmation orientés objet tels que C++ est le
masquage des données.
Le masquage des données fait référence à la restriction de l'accès aux données membres d'une classe. Cela
permet d'éviter que d'autres fonctions et classes ne falsifient les données de la classe.
Cependant, il est également important de rendre accessibles certaines fonctions membres et données
membres afin que les données cachées puissent être manipulées indirectement.
Les modificateurs d'accès de C++ nous permettent de déterminer quels membres de classe sont accessibles
aux autres classes et fonctions, et lesquels ne le sont pas.
Héritage C++
Ici, les variables patientNumber et diagnosis de la classe Patient sont masquées à l'aide du mot-clé private,
tandis que les fonctions membres sont rendues accessibles à l'aide du mot-clé public.
Modificateur d'accès public
Le mot-clé public est utilisé pour créer des membres publics (données et fonctions).
Les membres du public sont accessibles à partir de n'importe quelle partie du programme.
Héritage C++
Dans ce programme, nous avons créé une classe nommée Sample, qui contient une variable publique age
et une fonction publique displayAge().
Dans main(), nous avons créé un objet de la classe Sample nommé obj1. On accède alors directement aux
éléments publics en utilisant les codes obj1.age et obj1.displayAge().
Héritage C++
Notez que les éléments publics sont accessibles depuis main(). En effet, les éléments publics sont
accessibles à partir de toutes les parties du programme.
Héritage C++
Modificateur d'accès privé
Le mot-clé private est utilisé pour créer des membres privés (données et fonctions).
Les membres privés ne sont accessibles qu'à partir de la classe.
Cependant, les classes d'amis et les fonctions d'amis peuvent accéder aux membres privés
Héritage C++
Exemple 2 : spécificateur d'accès privé C++
Héritage C++
Dans main(), l'objet obj1 ne peut pas accéder directement à la variable de classe age.
Nous ne pouvons manipuler l'âge qu'indirectement via la fonction publique displayAge(), puisque cette
fonction initialise l'âge avec la valeur de l'argument qui lui est passé, c'est-à-dire le paramètre de fonction int
a.
Modificateur d'accès protégé
Avant de découvrir le spécificateur d'accès protégé, assurez-vous de connaître l'héritage en C++.
Le mot-clé protected est utilisé pour créer des membres protégés (données et fonction).
Les membres protégés sont accessibles dans la classe et à partir de la classe dérivée.
Héritage C++
Exemple 3 : spécificateur d'accès protégé par C++
Héritage C++
Ici, SampleChild est une classe héritée qui est dérivée de Sample. La variable age est déclarée dans
Sample avec le mot clé protected.
Cela signifie que SampleChild peut accéder à l'âge puisque Sample est sa classe parent.
Nous voyons cela car nous avons affecté la valeur de l'âge dans SampleChild même si l'âge est déclaré
dans la classe Sample.
Héritage C++
Résumé : public, private et protected
les éléments public sont accessibles par toutes les autres classes et fonctions.
les éléments private ne sont pas accessibles en dehors de la classe dans laquelle ils sont déclarés, sauf par
les classes et fonctions amies.
les éléments protected sont comme les private, sauf qu'ils sont accessibles par des classes dérivées.
Remarque : par défaut, les membres de la classe en C++ sont privés, sauf indication contraire.
Source : Javapoint.com
Héritage C++
Modes d'accès dans l'héritage C++
Jusqu'à présent, nous avons utilisé le mot-clé public afin d'hériter d'une classe d'une classe de base
existante. Cependant, nous pouvons également utiliser les mots-clés private et protected pour hériter des
classes. Par exemple,
Héritage C++
Les différentes façons dont nous pouvons dériver des classes sont appelées modes d'accès. Ces modes
d'accès ont l'effet suivant :
public : si une classe dérivée est déclarée en mode public, les membres de la classe de base sont hérités
par la classe dérivée tels quels.
private : dans ce cas, tous les membres de la classe de base deviennent des membres privés de la classe
dérivée.
protected : les membres publics de la classe de base deviennent des membres protégés dans la classe
dérivée.
Les membres privés de la classe de base sont toujours privés dans la classe dérivée.
Héritage C++
Remplacement d'une fonction membre dans l'héritage
Supposons que la classe de base et la classe dérivée aient des fonctions membres avec le même nom et les
mêmes arguments.
Si nous créons un objet de la classe dérivée et essayons d'accéder à cette fonction membre, la fonction
membre de la classe dérivée est invoquée au lieu de celle de la classe de base.
La fonction membre de la classe dérivée remplace la fonction membre de la classe de base.

Héritage multiple en C++
L'héritage multiple est le concept de l'héritage en C++ qui permet à une classe enfant d'hériter des propriétés
ou du comportement de plusieurs classes de base. Par conséquent, nous pouvons dire que c'est le
processus qui permet à une classe dérivée d'acquérir des fonctions membres, des propriétés, des
caractéristiques de plus d'une classe de base.
Syntaxe de l'héritage multiple
Problème ? Conflit lors de

l’utilisation de deux méthodes
de mêmes noms dans la
classe fille. Solution ?
Héritage multiple en C++
Ce problème peut être résolu en utilisant la fonction de résolution de portée pour spécifier quelle fonction
classer de base1 ou de base2
Héritage hiérarchique C++
Si plusieurs classes sont héritées de la classe de base, on parle d'héritage hiérarchique. Dans l'héritage
hiérarchique, toutes les fonctionnalités communes aux classes enfants sont incluses dans la classe de base.
Par exemple, la physique, la chimie, la biologie sont dérivées du cours de sciences. De même, Dog, Cat,
Horse sont dérivés de la classe Animal.
Syntaxe de l'héritage
hiérarchique
Héritage hiérarchique C++
Ici, les classes Dog et Cat sont toutes deux
dérivées de la classe Animal. Ainsi, les deux
classes dérivées peuvent accéder à la fonction
info() appartenant à la classe Animal.
Fonctions amies et
Classes amies
Friend Fonction et friend Classes
Le masquage des données est un concept fondamental de la programmation orientée objet. Il restreint
l'accès des membres privés de l'extérieur de la classe.
De même, les membres protégés ne sont accessibles que par les classes dérivées et sont inaccessibles de
l'extérieur. Par exemple,
Friend Function et friend Classes
Cependant, il existe une fonctionnalité en C++ appelée friend functions (fonctions amies) qui enfreint cette
règle et nous permet d'accéder aux fonctions membres de l'extérieur de la classe.
De même, il existe également une friend class (classe d'amis), que nous apprendrons plus tard dans ce
didacticiel.
Friend Function en C++
Une fonction amie peut accéder aux données privées et protégées d'une classe. Nous déclarons une
fonction friend en utilisant le mot-clé friend dans le corps de la classe.
Exemple :
Ici, addFive() est une fonction d'amie qui peut accéder à la fois aux membres de données privées et publics.
Bien que cet exemple nous donne une idée du concept de fonction d'amie, il ne montre aucune utilisation
significative.
Une utilisation plus significative serait d'opérer sur des objets de deux classes différentes. C'est alors que la
fonction ami peut être très utile.
Dans ce programme, ClassA et ClassB ont déclaré add() comme fonction friend. Ainsi, cette fonction peut
accéder aux données privées des deux classes.
Une chose à noter ici est que la fonction d'ami à l'intérieur de ClassA utilise la ClassB. Cependant, nous
n'avons pas défini ClassB à ce stade.
Pour que cela fonctionne, nous avons besoin d'une

déclaration avancée de ClassB dans notre
programme.
Classe amie en C++
Nous pouvons également utiliser une classe friend en C++ en utilisant le mot-clé friend. Par exemple,
Lorsqu'une classe est déclarée classe amie, toutes les fonctions membres de la classe amie deviennent des
fonctions amies.
Puisque ClassB est une classe d'amis, nous pouvons accéder à tous les membres de ClassA depuis ClassB.
Cependant, nous ne pouvons pas accéder aux membres de ClassB à partir de ClassA. C'est parce que la
relation d'ami en C++ est seulement accordée, pas prise.
Classe amie en C++
Nous pouvons également utiliser une classe friend en C++ en utilisant le mot-clé friend. Par exemple,
Classe amie en C++
Ici, ClassB est une classe amie de ClassA. Ainsi, ClassB a accès aux membres de classA.
En ClassB, nous avons créé une fonction add() qui renvoie la somme de numA et numB.
Puisque ClassB est une classe amie, nous pouvons créer des objets de ClassA à l'intérieur de ClassB.
Fonctions virtuelles C++
Fonctions virtuelles en C++
Une fonction virtuelle est une fonction membre de la classe de base que nous espérons redéfinir dans les
classes dérivées.
Fondamentalement, une fonction virtuelle est utilisée dans la classe de base afin de garantir que la fonction
est remplacée. Cela s'applique particulièrement aux cas où un pointeur de classe de base pointe vers un
objet d'une classe dérivée.
Par exemple, considérons le code ci-dessous :

Plus tard, si nous créons un pointeur de type Base pour pointer sur un objet de la classe Derived et appelons
la fonction print(), il appelle la fonction print() de la classe Base.
En d'autres termes, la fonction membre de Base n'est pas remplacée.

Afin d'éviter cela, nous déclarons la fonction print() de la classe Base comme virtuelle en utilisant le mot-clé
virtual.
Exemple
Ici, nous avons déclaré la fonction print() de Base comme virtuelle.
Ainsi, cette fonction est surchargée même lorsque nous utilisons un pointeur de type Base qui pointe vers
l'objet Derived protected1.
Identificateur de remplacement C++
C++ 11 nous a fourni un nouvel identifiant de substitution très utile pour éviter les bugs lors de l'utilisation de
fonctions virtuelles.
Cet identifiant spécifie les fonctions membres des classes dérivées qui remplacent la fonction membre de la
classe de base.
Par exemple,
Identificateur de remplacement C++
Si nous utilisons un prototype de fonction dans la classe dérivée et définissons cette fonction en dehors de la
classe, nous utilisons le code suivant :
Utilisation de la substitution C++
Lors de l'utilisation de fonctions virtuelles, il est possible de faire des erreurs lors de la déclaration des
fonctions membres des classes dérivées.
L'utilisation de l'identifiant de substitution invite le compilateur à afficher des messages d'erreur lorsque ces
erreurs sont commises.
Sinon, le programme compilera simplement mais la fonction virtuelle ne sera pas écrasée.
Utilisation de la substitution C++
Certaines de ces erreurs possibles sont :
➢ Fonctions avec des noms incorrects : par exemple, si la fonction virtuelle dans la classe de base est
nommée print(), mais que nous nommons accidentellement la fonction de substitution dans la classe
dérivée pint().
➢ Fonctions avec différents types de retour : si la fonction virtuelle est, disons, de type void mais que la
fonction dans la classe dérivée est de type int.
➢ Fonctions avec des paramètres différents : Si les paramètres de la fonction virtuelle et les fonctions des
classes dérivées ne correspondent pas.
Aucune fonction virtuelle n'est déclarée dans la classe de base.

Utilisation des fonctions virtuelles C++
Supposons que nous ayons une classe de base Animal et des classes dérivées Dog et Cat.
Supposons que chaque classe a un membre de données nommé type. Supposons que ces variables soient
initialisées via leurs constructeurs respectifs.
Supposons maintenant que notre programme nous oblige à créer deux fonctions publiques pour chaque
classe :
getType() pour renvoyer la valeur de type
print() pour imprimer la valeur de type
Nous pourrions créer ces deux fonctions dans chaque classe séparément et les surcharger, ce qui sera long
et fastidieux.
Ou nous pourrions rendre getType() virtuel dans la classe Animal, puis créer une fonction print() unique et
distincte qui accepte un pointeur de type Animal comme argument. Nous pouvons ensuite utiliser cette
fonction unique pour remplacer la fonction virtuelle.
Cela rendra le code plus court, plus propre et moins répétitif.

Ici, nous avons utilisé la fonction virtuelle getType() et un ani de pointeur Animal
afin d'éviter de répéter la fonction print() dans chaque classe.
Dans main(), nous avons créé 3 pointeurs Animal pour créer dynamiquement
des objets des classes Animal, Dog et Cat.
Nous appelons ensuite la fonction print() à l'aide de ces pointeurs :
Lorsque print(animal1) est appelé, le pointeur pointe sur un objet Animal. Ainsi, la fonction
virtuelle de la classe Animal est exécutée à l'intérieur de print().
Lorsque print(dog1) est appelé, le pointeur pointe sur un objet Dog. Ainsi, la fonction virtuelle
est remplacée et la fonction de Dog est exécutée à l'intérieur de print().
Lorsque print(cat1) est appelé, le pointeur pointe sur un objet Cat. Ainsi, la fonction virtuelle
est remplacée et la fonction de Cat est exécutée à l'intérieur de print().
Templates C++
Notions de Template
Les template sont des fonctionnalités puissantes de C++ qui nous permettent d'écrire des programmes
génériques. Nous pouvons implémenter des template de deux manières :
Template de fonction
Template de classes
Semblable aux template de fonction, nous pouvons utiliser des template de classe pour créer une seule
classe pour travailler avec différents types de données.
Les modèles de classe sont utiles car ils peuvent rendre notre code plus court et plus gérable.
Notions de Template
Déclaration de template de classe
Un template de classe commence par le mot-clé template suivi du ou des paramètres de modèle à
l'intérieur de <> qui est suivi de la déclaration de classe
Notions de Template
Dans la déclaration ci-dessus, T est l'argument du template qui est un espace réservé pour le type de
données utilisé, et class est un mot-clé.
À l'intérieur du corps de la classe, une variable membre var et une fonction membre functionName() sont
toutes deux de type T.
Création d'un objet de template de classe
Une fois que nous avons déclaré et défini un template de classe, nous pouvons créer ses objets dans
d'autres classes ou fonctions (telles que la fonction main()) avec la syntaxe suivante :
Notions de Template
Exemple :
Notions de Template
Dans ce programme. nous avons créé un template de classe Number avec le code
Notez que la variable num, l'argument constructeur n et la fonction getNum() sont de type T, ou ont un type
de retour T. Cela signifie qu'ils peuvent être de n'importe quel type.
Notions de Template
Dans main(), nous avons implémenté le template de classe en créant ses objets
Notez les codes Number<int> et Number<double> dans le code ci-dessus.
Cela crée une définition de classe pour int et float, qui sont ensuite utilisées en conséquence.
Il est obligatoire de spécifier le type lors de la déclaration des objets des template de classe. Sinon, le
compilateur produira une erreur.
Notions de Template
Définir un membre de classe en dehors du template de classe
Supposons que nous ayons besoin de définir une fonction en dehors du template de classe. Nous pouvons
le faire avec le code suivant :
Notions de Template
Exemple 2 : calculatrice simple utilisant des template de classe
Ce programme utilise un template de classe pour effectuer l'addition, la soustraction, la multiplication et la

division de deux variables num1 et num2.
Les variables peuvent être de n'importe quel type, bien que nous n'ayons utilisé que les types int et float
dans cet exemple.
Notions de Template
Notions de Template
Dans le programme ci-dessus, nous avons déclaré un template de classe Calculator.
La classe contient deux membres privés de type T : num1 & num2, et un constructeur pour initialiser les
membres.
Nous avons également des fonctions add (), subtract (), multiplier () et divise () qui ont le type de retour T.
Nous avons également une fonction void displayResult () qui imprime les résultats des autres fonctions.
Dans main(), nous avons créé deux objets de Calculator : un pour le type de données int et un autre pour le
type de données float.
Notions de Template
Template de classe C++ avec plusieurs paramètres
En C++, nous pouvons utiliser plusieurs paramètres de template et même utiliser des arguments par défaut
pour ces paramètres. Par exemple,
Notions de Template
Exemple 3 : template C++ avec plusieurs paramètres
Notions de Template
Dans ce programme, nous avons créé un template de classe, nommé ClassTemplate, avec trois
paramètres, l'un d'eux étant un paramètre par défaut.
Notez le code class V = char. Cela signifie que V est un paramètre par défaut dont le type par défaut est
char.
Dans ClassTemplate, nous déclarons 3 variables var1, var2 et var3, chacune correspondant à l'un des
paramètres du modèle.
Notions de Template
Dans main(), nous créons deux objets de ClassTemplate avec le code

Notions de Template
Ici,
Pour obj1, T = int, U = double et V = car.
Pour obj2, T = double, U = char et V = bool.

Merci
cyrillembia@iaicameroun.com
iaicameroun.com
Suivre les actualités sur les plateformes

de l’IAI-Cameroun :

P.O.O Partie 2 Suite Et Fin - 023615

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

P.O.O Partie 2 Suite Et Fin - 023615

Transféré par

Droits d'auteur :

Formats disponibles

Cours P.O.

Par Cyrille MBIA

✓ Vitesse - Comme la programmation C, les performances du code C++ optimisé sont

✓ C++ vous aide à comprendre l'architecture interne d'un ordinateur, comment

✓ Écrire beaucoup de code de programmation C++ - La seule façon d'apprendre la

1 Flux de contrôles 3 Tableaux et

Introduction 2 Fonctions 4 Structures

▪ Variables et littéraux C++

▪ Types de données C++

▪ E/S de base C++

▪ Conversion de types C++

La valeur d'une variable peut être modifiée, d'où le nom de variable.

int age = 14; // age est égal à 14

age = 17; // age est égal à 17

Les noms de variables ne doivent pas commencer par un caractère majuscule.

décimal (base 10)

hexadécimal (base 16)

Remarque : E-5 = 10-5

Afin d'utiliser ces caractères, des séquences d'échappement sont utilisées.

"bonne" constante de chaîne

"" constante de chaîne nulle

" " constante de chaîne de un espace blanc

constante de chaîne "x" ayant un seul caractère

const int LIGHT_SPEED = 299792458;

LIGHT_SPEED = 2500 // Error! LIGHT_SPEED is a constant.

int age = 13;

Le tableau ci-dessous présente les types de données fondamentaux, leur signification et

float Virgule flotante 4

double Double virgule flotante 8

wchar_t Caractère large 2

using namespace std;

// imprime la chaîne entre guillemets doubles

cout << "This is C++ Programming";

// imprime la chaîne entre guillemets doubles

std::cout << "This is C++ Programming";

using namespace std;

int num1 = 70;

double num2 = 256.783;

cout << num1 << endl; // print integer

cout << num2 << endl; // print double

cout << "character: " << ch << endl; // print char

cout << "character: " << ch << endl;

using namespace std;

cout << "Enter an integer: ";

cin >> num; // Taking input

cout << "The number is: " << num;

using namespace std;

cout << "Enter a character and an integer: ";

cin >> a >> num;

cout << "Character: " << a << endl;

cout << "Number: " << num;

Il existe deux types de conversion de type en C++.

✓ Conversion explicite (également connue sous le nom de casting)

✓ Opérateurs au niveau du bit

En programmation informatique, nous utilisons l'instruction if pour exécuter un code de bloc

si le pourcentage est supérieur à 90, attribuez la note A

si le pourcentage est supérieur à 75, attribuez la note B

si le pourcentage est supérieur à 65, attribuez la note C

Déclaration if... else

Instruction if... else if... else

La syntaxe de l'instruction if est :

L'instruction if évalue la condition entre parenthèses ( ).

Si la condition est vraie, le code à l'intérieur du corps de if est exécuté.