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 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 soit un prototype de maison. Il montre l'emplacement et les dimensions des portes, windows, étages, etc. À partir de ces descriptions, nous pouvons construire une maison. La maison devient l'objet. Il est possible de créer plusieurs maisons à partir du prototype. De plus, il est possible de créer de nombreux objets à partir d'une classe.

Classe C++

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.

Déclaration de classe

En C+, une classe est définie à l’aide du mot-clé class. Cela 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 classe est le nom à attribuer à la classe.
  • Les données sont les données de la classe, normalement déclarées sous forme de variables.
  • Les fonctions sont les fonctions de classe.

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.

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 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éé.
  • Le nom de l'objet est le nom à attribuer au nouvel objet.

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

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 :

Accès aux membres de données

Voici une capture d'écran du code :

Accès aux membres de données

Explication du code:

  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éclarer le coût variable d'un double type de données.
  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().

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.

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

Accès aux membres de données

Voici une capture d'écran du code :

Accès aux membres de données

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 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().

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 :

Accès aux membres de données

Voici une capture d'écran du code :

Accès aux membres de données

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 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().

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

Fonctions des membres de la classe

Voici une capture d'écran du code :

Fonctions des membres de la classe

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 la classe que nous sommes sur le point de créer comme 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 print(). Cette fonction est définie dans la définition de classe. Son corps a été ajouté dans la définition de 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 de la classe 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 la classe Guru99 et donnez-lui le nom guru99.
  18. Utilisez l'instance ci-dessus pour attribuer une valeur 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().

Constructeurs et destructeurs

Qu'est-ce que les constructeurs ?

Les constructions sont des fonctions spéciales qui initialisent des objets. Le Compilateurs C++ appelle 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 ait 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 :

Constructeurs et destructeurs

Voici une capture d'écran du code :

Constructeurs et destructeurs

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 publiquement.
  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 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é. Le endl est un mot-clé C++, 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().

Résumé

  • C + + est orienté objet.
  • Les classes constituent les principales fonctionnalités du 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 modèle pour un objet.
  • Les classes déterminent la forme d'un objet.
  • Les données et 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.