Classe et objet C++ avec exemple

Qu'est-ce qu'une classe ?

Une classe C++ combine des données et des méthodes pour manipuler les données en une seule. Les classes déterminent également les formes des objets. Les données et les méthodes contenues dans une classe sont appelées membres de classe. Une classe est un type de données défini par l'utilisateur. Pour accéder aux membres de la classe, nous utilisons une instance de la classe. Vous pouvez voir une classe comme un plan pour un objet.

Une classe être un prototype pour une maison. Il montre l'emplacement et la taille des portes, des fenêtres, des sols, etc. À partir de ces descriptions, nous pouvons construire une maison. La maison devient l'objet. Il est possible de créer de nombreuses maisons à partir du prototype. De plus, il est possible de créer plusieurs objets à partir d'une classe.

Dans la figure ci-dessus, nous avons un prototype de maison individuelle. A partir de ce prototype, nous avons créé deux maisons aux caractéristiques différentes.

Dans ce didacticiel, vous apprendrez :

• Qu'est-ce qu'une classe ?
• Exemple de classe
• Mots clés privés et publics
• Définition d'objet
• Accéder aux données des membres
• Fonctions de membre de classe
• Constructeurs et destructeurs

Déclaration de classe

En C+, une classe est définie à l'aide du mot-clé class. Il doit être suivi du nom de la classe. Le corps de la classe est ensuite ajouté entre accolades { }.

Syntaxe :

class class-name
   {
   // data
   // functions
   };

• Le nom de la classe est le nom à attribuer à la classe.
• Les données sont les données de la classe, normalement déclarées en tant que variables.
• Les fonctions sont les fonctions de classe.

Mots clés privés et publics

Vous devez avoir rencontré ces deux mots-clés. Ce sont des modificateurs d'accès.

• Privé :

Lorsque le mot clé private est utilisé pour définir une fonction ou une classe, il devient private. Ceux-ci ne sont accessibles qu'à partir de la classe.

• Public :

Le mot-clé public, quant à lui, rend les données/fonctions publiques. Ceux-ci sont accessibles depuis l'extérieur de la classe.

Définition d'objet

Les objets sont créés à partir de classes. Les objets de classe sont déclarés de la même manière que les variables sont déclarées. Le nom de la classe doit commencer, suivi du nom de l'objet. L'objet du type de classe.

Syntaxe :

class-name object-name;

• Le nom de classe est le nom de la classe à partir de laquelle un objet doit être créé.
• Object-name est le nom à attribuer au nouvel objet.

Ce processus de création d'un objet à partir d'une classe est appelé instanciation.

Accéder aux données des membres

Pour accéder aux membres publics d'une classe, nous utilisons l'opérateur (.)dot. Ce sont des membres marqués avec un modificateur d'accès public.

Exemple 1 :

#include <iostream>
using namespace std;
class Phone {
public:
	double cost;   
	int slots; 
};
int main() {
	Phone Y6;        
	Phone Y7;        

	Y6.cost = 100.0;
	Y6.slots = 2;

	Y7.cost = 200.0;
	Y7.slots = 2;
	cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
	cout << "Cost of Huawei Y7 : " << Y7.cost << endl;

	cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
	cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;

	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre code afin d'utiliser ses fonctions.
2. Inclure l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
3. Déclarez une classe nommée Phone.
4. Utiliser le modificateur d'accès public pour marquer les variables que nous sommes sur le point de créer comme accessibles au public.
5. Déclarez le coût variable d'un type de données double.
6. Déclarez une variable entière nommée slots.
7. Fin du corps de la classe.
8. Appeler la fonction main(). La logique du programme doit être ajoutée dans son corps.
9. Créez un objet nommé Y6 de type Téléphone. C'est ce qu'on appelle l'instanciation.
10. Créez un objet nommé Y7 de type Téléphone. C'est ce qu'on appelle l'instanciation.
11. Accéder au coût variable/membre de la classe Phone à l'aide de l'objet Y6. La valeur est définie sur 100,0. Le coût de Y6 est désormais fixé à 100,0.
12. Accéder aux slots variables/membres de la classe Phone à l'aide de l'objet Y6. La valeur est définie sur 2. Les emplacements pour Y6 sont désormais définis sur 2.
13. Accéder au coût variable/membre de la classe Phone à l'aide de l'objet Y7. La valeur est définie sur 200,0. Le coût de Y7 est désormais fixé à 200,0.
14. Accéder aux emplacements variables/membres de la classe Phone à l'aide de l'objet Y7. La valeur est définie sur 2. Les emplacements pour Y7 sont désormais définis sur 2.
15. Imprimez le coût de Y6 sur la console à côté d'un autre texte.
16. Imprimez le coût de Y7 sur la console à côté d'un autre texte.
17. Imprimez le nombre d'emplacements pour Y6 à côté d'un autre texte.
18. Imprimez le nombre d'emplacements pour Y7 à côté d'un autre texte.
19. Le programme doit renvoyer une valeur en cas de réussite.
20. Fin du corps de la fonction main().

Qu'est-ce qu'un cours privé ?

Les membres de classe marqués comme privés ne sont accessibles qu'aux fonctions définies dans la classe. Tout objet ou fonction défini en dehors de la classe ne peut pas accéder directement à ces membres. Un membre de classe privée n'est accessible que par les fonctions de membre et d'ami.

Qu'est-ce qu'une classe protégée ?

Les membres du groupe marqués comme protégés ont un avantage sur ceux marqués comme privés. Ils sont accessibles par des fonctions dans la classe de leur définition. De plus, ils sont accessibles à partir des classes dérivées.

Exemple 2 :

#include <iostream>
using namespace std;
class ClassA {
public:
	void set_a(int val);
	int get_a(void);

private:
	int a;
};
int ClassA::get_a(void) {
	return a;
}
void ClassA::set_a(int val) {
	a = val;
}
int main() {
	ClassA a;
	a.set_a(20); 
	cout << "Value of a is: " << a.get_a(); 
	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
3. Créez une classe nommée ClassA.
4. Utilisez le modificateur d'accès public pour marquer le membre de classe à créer comme accessible au public.
5. Créez la fonction nommée set_a() qui prend une valeur entière val.
6. Créez une fonction nommée get_a().
7. Utilisez le modificateur d'accès privé pour marquer le membre de classe à créer comme accessible en privé.
8. Déclarez une variable entière nommée a.
9. Fin du corps de la classe.
10. Utilisez le nom de la classe et l'opérateur de résolution de portée pour accéder à la fonction get_a(). Nous voulons définir ce que fait la fonction lorsqu'elle est invoquée.
11. La fonction get_a() doit renvoyer la valeur de la variable a lorsqu'elle est invoquée.
12. Fin de la définition de la fonction get_a().
13. Utilisez le nom de la classe et l'opérateur de résolution de portée pour accéder à la fonction set_a(). Nous voulons définir ce que fait la fonction lorsqu'elle est invoquée.
14. Affectation de la valeur de la variable val à la variable a.
15. Fin de définition de la fonction set_a().
16. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
17. Créez une instance de ClassA et donnez-lui le nom a.
18. Utilisez l'instance de classe ci-dessus et la fonction set_a() pour attribuer une valeur de 20 à la variable a.
19. Imprimer du texte à côté de la valeur de la variable a sur la console. La valeur de la variable a est obtenue en appelant la fonction get_a().
20. Le programme doit renvoyer une valeur en cas de réussite.
21. Fin du corps de la fonction main().

Exemple 3 :

#include <iostream>
using namespace std;
class ParentClass {
protected:
	int value;
};
class ChildClass : public ParentClass {
public:
	void setId(int x) {
		value = x;
	}
	void displayValue() {
	cout << "Value is: " << value << endl;
	}
};
int main() {
	ChildClass c;
	c.setId(21);
	c.displayValue();
	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
3. Créez une classe nommée ParentClass.
4. Utilisez le modificateur d'accès protégé pour marquer le membre de classe à créer comme protégé.
5. Créez une variable entière nommée valeur.
6. Fin du corps de la classe.
7. Créez une nouvelle classe nommée ChildClass qui hérite de ParentClass.
8. Utilisez le modificateur d'accès protégé pour marquer le membre de classe à créer comme accessible aux classes enfants.
9. Créez la fonction nommée setId() qui prend une valeur entière x.
10. Affectation de la valeur de la variable x à la valeur de la variable.
11. Fin de définition de la fonction setId().
12. Créez une fonction nommée displayValue().
13. Imprimez la valeur de la variable nommée value sur la console à côté d'un autre texte.
14. Fin du corps de la fonction displayValue().
15. Fin du corps de la classe nommée ChildClass.
16. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
17. Créez une instance de ChildClass et nommez-la c.
18. Utilisez l'instance de classe ci-dessus et la fonction setId() pour attribuer une valeur de 21 à la variable x.
19. Utilisez l'instance de classe ci-dessus pour appeler la fonction nommée displayValue().
20. Le programme doit renvoyer une valeur en cas de réussite.
21. Fin du corps de la fonction main().

Fonctions des membres de classe

Les fonctions nous aident à manipuler les données. Les fonctions membres de classe peuvent être définies de deux manières :

• Dans la définition de classe
• En dehors de la définition de classe

Si une fonction doit être définie en dehors d'une définition de classe, nous devons utiliser l'opérateur de résolution de portée (::). Cela doit être accompagné des noms de classe et de fonction.

Exemple 2 :

#include <iostream>
#include <string>
using namespace std;
class Guru99
{
public:
	string tutorial_name;
	int id;
	void printname();
	void printid()
	{
		cout << "Tutorial id is: "<< id;
	}
};
void Guru99::printname()
{
	cout << "Tutorial name is: " << tutorial_name;
}
int main() {
	Guru99 guru99;
	guru99.tutorial_name = "C++";
	guru99.id = 1001;
	guru99.printname();
	cout << endl;
	guru99.printid();
	return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Incluez le fichier d'en-tête iostream dans notre programme pour utiliser ses fonctions.
2. Incluez le fichier d'en-tête de chaîne dans notre programme pour utiliser ses fonctions.
3. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
4. Créez une classe nommée Guru99.
5. Utilisez le modificateur d'accès public pour marquer les membres de classe que nous sommes sur le point de créer comme accessibles au public.
6. Créez une variable de chaîne nommée tutorial_name.
7. Créez une variable entière nommée id.
8. Créez une fonction nommée printname(). Cette fonction n'est pas définie dans la définition de classe.
9. Créez une fonction nommée print(). Cette fonction est définie dans la définition de classe. Son corps a été ajouté dans la définition de la classe.
10. Imprimez la valeur de la variable id à côté d'un autre texte sur la console. Notez que ceci a été ajouté dans le corps de la fonction printid(). Il ne sera exécuté que lorsque la fonction printid() sera appelée.
11. Fin du corps de la fonction printid().
12. Fin du corps de la classe Guru99.
13. Le début de la définition de la fonction printname().
14. Imprimez la valeur de la variable tutorial_name sur la console à côté d'un autre texte. Notez que ceci a été ajouté dans le corps de la fonction printname(). Il ne sera exécuté que lorsque la fonction printname() sera appelée.
15. Fin de la définition de la fonction printname().
16. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
17. Créez une instance de la classe Guru99 et donnez-lui le nom de guru99.
18. Utilisez l'instance ci-dessus pour attribuer une valeur C++ à la variable tutorial_name.
19. Utilisez l'instance guru99 pour attribuer la valeur 1001 à la variable id.
20. Utilisez l'instance guru99 pour appeler la fonction printname() .
21. Appelez la commande end (end line) pour imprimer une nouvelle ligne vierge sur la console.
22. Utilisez l'instance guru99 pour appeler la fonction printid().
23. Le programme doit renvoyer une valeur en cas de réussite.
24. Fin du corps de la fonction main().

Constructeurs et destructeurs

Qu'est-ce que les constructeurs ?

Les constructions sont des fonctions spéciales qui initialisent des objets. Les compilateurs C++ appellent un constructeur lors de la création d'un objet. Les constructeurs aident à attribuer des valeurs aux membres de la classe. Bien sûr, c'est après qu'on leur a alloué de l'espace mémoire.

Qu'est-ce que les destructeurs ?

Les destructeurs, quant à eux, aident à détruire les objets de classe.

Le nom du constructeur doit être similaire au nom de la classe. Les constructeurs n'ont pas de type de retour.

Le constructeur peut être défini à l'intérieur ou à l'extérieur du corps de la classe. S'il est défini en dehors du corps de la classe, il doit être défini avec le nom de la classe et l'opérateur de résolution de portée (::).

Exemple 3 :

#include <iostream>  
using namespace std;
class ClassA {
public:
	ClassA() {
		cout << "Class constructor called"<<endl;
	}
	~ClassA() {
		cout << "Class destructor called"<<endl;
	}
};

int main() {
	ClassA a;
	int p = 1;
		if (p) {
			ClassA b; 
		}   
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Incluez le fichier d'en-tête iostream dans le code pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
3. Créez une classe nommée ClassA.
4. Utilisez le modificateur d'accès public pour marquer le membre que nous sommes sur le point de créer comme accessible au public.
5. Créez un constructeur pour la classe.
6. Texte à imprimer sur la console lorsque le constructeur est appelé. Le endl est un mot-clé C++, qui signifie ligne de fin. Il déplace le curseur de la souris à la ligne suivante.
7. Fin du corps du constructeur de classe.
8. Créez un destructeur pour la classe.
9. Texte à imprimer sur la console lorsque le destructeur est appelé. Le endl est un mot-clé C++, qui signifie ligne de fin. Il déplace le curseur de la souris à la ligne suivante.
10. Fin du corps du destructeur.
11. Fin du corps de la classe.
12. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de cette fonction.
13. Créez un objet de classe et donnez-lui le nom a. Le constructeur sera appelé.
14. Créez une variable entière nommée p et attribuez-lui la valeur 1.
15. Créez un bloc d'instruction if à l'aide de la variable p.
16. Créez un objet de classe et donnez-lui le nom b. Le destructeur sera appelé.
17. Fin du corps de l'instruction if.
18. Fin du corps de la fonction main().

Résumé :

• C++ est orienté objet.
• Les classes constituent les principales fonctionnalités de C++ qui le rendent orienté objet.
• Une classe C++ combine des données et des méthodes pour manipuler les données en une seule.
• Une classe est un plan pour un objet.
• Les classes déterminent la forme d'un objet.
• Les données et les méthodes contenues dans une classe sont appelées membres de classe.
• Pour accéder aux membres de la classe, vous devez utiliser une instance de la classe.
• Pour créer une classe, nous utilisons le mot-clé class.
• Les fonctions membres de la classe peuvent être définies à l'intérieur ou à l'extérieur d'une classe.