C++ Classe et objet avec exemple

Qu'est-ce qu'une classe ?

A C++ La classe combine les données et les méthodes de manipulation des données en une seule. Les classes déterminent également les formes des objets. Les données et 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 modèle pour un objet.

Une classe peut servir de prototype pour une maison. Elle définit l'emplacement et les dimensions des portes, des fenêtres, des étages, etc. À partir de ces descriptions, on peut construire une maison. La maison devient alors l'objet. Il est possible de créer plusieurs maisons à partir du prototype. De même, il est possible de créer plusieurs objets à partir d'une classe.

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

En gardant à l'esprit l'idée d'une classe comme modèle, l'étape suivante consiste à voir comment elle est déclarée dans le code.

Déclaration de classe

In C++Une classe est définie à l'aide du mot-clé `class`. Celui-ci 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 du cours est le nom à attribuer à la classe.
• Le données, il s'agit des données de la classe, normalement déclarées comme des variables.
• Le fonctions ce sont les fonctions de la classe.

La déclaration du nom et du corps de la classe soulève naturellement la question de savoir qui peut utiliser chaque membre.

Mots-clés privés et publics

Vous avez dû tomber sur 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 privé. Ceux-ci ne sont accessibles qu’à partir de la classe.

Publique:

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

Une fois qu'une classe existe, on peut créer des objets à partir de celle-ci, de la même manière que l'on crée des variables à partir d'un type de données.

Définition de l'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 : le nom de la classe précède le nom de l’objet. L’objet est du type de la classe.

Syntaxe

class-name object-name;

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

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

Une fois un objet créé, ses membres publics sont accessibles directement via un opérateur simple.

Accès aux membres de données

Pour accéder aux membres publics d'une classe, nous utilisons l'opérateur point (.). Ce sont des membres marqués d’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 :

Code Explication:

1. Incluez 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 classe.
8. Appel de 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édez au coût variable/membre de la classe Télé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édez 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édez au coût variable/membre de la classe Télé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édez aux slots 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 du Y6 sur la console à côté d’un autre texte.
16. Imprimez le coût du 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 une fois terminé.
20. Fin du corps de la fonction main().

Les membres publics ont accès au code externe, mais les membres privés sont soumis à des règles d'accès beaucoup plus strictes.

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

Les membres de la classe marqués comme privés ne sont accessibles que par les fonctions définies au sein de 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 membre et ami.

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 :

Code Explication:

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 publiquement.
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 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. Impression d'un 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 de la valeur une fois terminé.
21. Fin du corps de la fonction main().

Les membres protégés se situent entre les membres privés et publics, ajoutant une fonctionnalité clé pour l'héritage.

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 les fonctions au sein de la classe de leur définition. De plus, ils sont accessibles à partir des classes dérivées.

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 :

Code Explication:

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 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 valeur sur la console avec 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 donnez-lui le nom 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 de la valeur une fois terminé.
21. Fin du corps de la fonction main().

Outre le stockage des données, une classe regroupe également les fonctions qui opèrent sur ces données.

Fonctions des membres de la classe

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

• À l'intérieur de 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 4

#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 :

Code Explication:

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 indiquer que les membres de la classe que nous allons créer seront accessibles au public.
6. Créez une variable de chaîne nommée nom_tutoriel.
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 printid(). Cette fonction est définie dans la définition de la classe. Son corps a été ajouté dans la définition de la classe.
10. Imprimez la valeur de la variable id avec un autre texte sur la console. Notez que cela 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 du cours Guru99.
13. Le début de la définition de la fonction printname().
14. Imprimez la valeur de la variable tutoriel_name sur la console avec un autre texte. Notez que cela 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 classe Guru99 et lui donnant le nom de guru99.
18. Utilisez l'exemple ci-dessus pour attribuer une valeur de C++ à la variable nom_tutoriel.
19. Utilisez l'instance guru99 pour attribuer une valeur de 1001 à l'identifiant de la variable.
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 de la valeur une fois terminé.
24. Fin du corps de la fonction main().

Deux fonctions membres spéciales s'exécutent automatiquement lors de la création d'un objet et lors de sa destruction.

Constructeurs et destructeurs

Qu'est-ce qu'un constructeur ?

Les constructeurs sont des fonctions spéciales qui initialisent les objets. C++ compilateurs Lors de la création d'un objet, on appelle un constructeur. Les constructeurs permettent d'assigner des valeurs aux membres de la classe, après leur avoir alloué de la mémoire.

Qu'est-ce qu'un destructeur ?

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 5

#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 :

Code Explication:

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 publiquement.
5. Créez un constructeur pour la classe.
6. Texte à imprimer sur la console lorsque le constructeur est appelé. La fin est un C++ mot-clé, qui signifie ligne de fin. Il déplace le curseur de la souris vers 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é. La fin est un C++ mot-clé, qui signifie ligne de fin. Il déplace le curseur de la souris vers la ligne suivante.
10. Fin du corps du destructeur.
11. Fin du corps de 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 en utilisant 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().

FAQ