Menu

Classes et objets en C ++

classes objects c

Essayez Notre Instrument Pour Éliminer Les Problèmes

Une brève introduction aux classes et objets en C ++.

Les classes et les objets sont les blocs de construction de la programmation orientée objet en C ++. Chaque entité, vivante ou non vivante, peut être représentée comme un objet et programmée en conséquence en utilisant C ++. Ainsi, des entités comme une voiture, un bureau, une personne, un oiseau, un animal, etc. peuvent être représentées comme des objets.

La classe est un niveau supérieur à l'objet et représente la catégorie des objets. Ainsi, la classe agit comme un modèle qui décrit la conception et les détails de l'objet. Cela inclut les données utilisées pour décrire l'objet et diverses méthodes ou fonctions pouvant agir sur les données de l'objet.

=> Regardez la série de formations C ++ simple ici.

Dans ce didacticiel, nous abordons tous les détails de la classe et des objets en C ++ ainsi que leur représentation par programmation.

Classes et objets en C ++

Ce que vous apprendrez:

Des classes

Une classe en C ++ peut être considérée comme un plan ou un squelette d'une entité particulière. La classe est un type de données défini par l'utilisateur. Il contient les informations générales ou les données de cette entité particulière et les fonctions qui opèrent sur cette entité.

Dans la syntaxe C ++, nous définissons une classe avec le mot-clé «classe» suivi du nom de la classe.

Le nom de la classe est suivi des détails de la classe entre accolades et se termine par un point-virgule.

Le bloc suivant montre la syntaxe générale de la définition de classe.

Syntaxe générale des classes

Comme indiqué dans la représentation ci-dessus, la classe peut avoir des spécificateurs d'accès tels que public / protected / private. Il peut avoir des membres de données et des fonctions membres. Les données et les fonctions sont appelées en tant que membres de la classe. Par défaut, les membres sont privés de la classe, de sorte qu'aucune entité extérieure n'a accès à ces membres.

Par exemple, un véhicule peut être une classe généralisée ayant des propriétés comme un modèle, une couleur, un numéro de châssis, une vitesse moyenne, etc. Il peut avoir des fonctions comme changeModel, accélération, ralentissement, etc. qui exécutent des actions sur les données membres. Nous pouvons définir une classe nommée «véhicule» qui aura toutes ces données membres et fonctions.

Comme déjà mentionné, une classe n'est qu'un modèle pour les entités. Il ne prend aucun espace en mémoire lorsqu'il est défini. Pour qu'une classe soit fonctionnelle, nous devons définir des objets qui peuvent utiliser les membres de la classe.

Objets

Afin d'utiliser la fonctionnalité de classe, nous devons instancier la classe pour créer un objet. Un objet est une instance d'une classe. J'ai des mots simples, on peut dire qu'un objet est une variable de type classe.

La syntaxe générale pour créer un objet est:

classname object_name;

Une fois l'objet créé, il peut être utilisé pour accéder aux données membres et aux fonctions de cette classe.

L'accès aux membres de la classe (données et fonctions) se fait à l'aide de l'opérateur point (.), Également appelé opérateur d'accès aux membres.

Si obj est le nom de l'objet et qu'il existe une fonction «display ()» dans la classe, alors la fonction est accessible sous «obj.display ()».

Cependant, il y a un hic dans la déclaration ci-dessus. On peut accéder à la fonction display () à l'aide d'un objet et de l'opérateur point si la fonction est «publique».

Spécificateurs d'accès

En C ++, l'accès aux membres de données et aux fonctions de la classe dépend de l'accès donné à ce membre de données ou à cette fonction particulière à l'aide d'un spécificateur d'accès.

C ++ prend en charge les spécificateurs d'accès suivants:

# 1) Privé

Il s'agit du spécificateur d'accès par défaut pour une classe en C ++. Cela signifie que si aucun spécificateur d'accès n'est spécifié pour les membres d'une classe, il est considéré comme privé.

Lorsqu'un membre est privé, il n'est pas accessible en dehors de la classe. Pas même en utilisant l'objet et l'opérateur point. Les membres de données privées ne sont accessibles qu'à l'aide des fonctions membres de la classe.

applications pour convertir des vidéos youtube en mp3

Cependant, il existe une exception à cette règle, dont nous parlerons dans nos prochains sujets.

# 2) Publique

Un membre de données ou une fonction qui est défini comme public dans la classe est accessible à tout le monde en dehors de la classe. Ces membres sont accessibles à l'aide de l'objet et de l'opérateur point.

# 3) Protégé

Un membre protégé d'une classe est accessible à la classe elle-même et aux classes enfants de cette classe.

Ce spécificateur d'accès est particulièrement utilisé en cas d'héritage et nous en discuterons en détail tout en discutant du sujet de l'héritage.

Prenons l'exemple suivant pour mieux comprendre ces spécificateurs d'accès.

#include #include using namespace std; class ABC{ int var1 = 10; public: string name; void display() { cout<<'var1 ='<

Production:

var1 = 10
nom = qc

Dans ce programme, nous avons deux membres de données parmi lesquels var1 de type int est private (spécificateur d'accès non spécifié. La valeur par défaut est private). Un autre membre est le nom de la chaîne, qui est déclaré public. Nous avons encore un autre affichage de fonction qui affiche la valeur de ces deux membres.

Dans la fonction principale, nous déclarons un objet abc de classe ABC. Ensuite, nous définissons les valeurs des membres de données et également l'affichage de la fonction d'appel à l'aide de l'objet «abc».

Cependant, lorsque le compilateur rencontre la ligne abc.var1 = 20; cela générera une erreur indiquant que «var1 est une variable privée».

C'est parce que nous ne pouvons pas accéder aux données privées membres d'une classe en dehors de la classe. Il y a donc une erreur. Mais on peut y accéder à l'intérieur de la fonction et donc quand on sort la valeur de var1 dans la fonction d'affichage; il ne jette aucune erreur.

Par conséquent, la sortie du programme affiche la valeur initiale avec laquelle var1 est déclarée.

Jusqu'à présent, nous avons vu les détails sur les classes, les objets et les spécificateurs d'accès, prenons maintenant un exemple complet d'un exemple d'élève de classe. Cette classe a des membres de données: student_id, student_name et student_age. Il dispose également de fonctions membres pour lire les informations sur les étudiants et afficher les informations sur les étudiants.

Afin de faciliter les choses pour les lecteurs, nous avons déclaré tous les membres de la classe comme publics.

Le programme suivant montre l'implémentation complète.

#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; void read_studentInfo(); void print_studentInfo() { cout<<' Student ID : '<student_id; cout<>student_name; cout<>student_age; } int main() { student s1; s1.read_studentInfo(); s1.print_studentInfo(); }

Production:

Entrez l'ID étudiant: 1

Entrez le nom_étudiant: abc

Entrez student_age: 12

ID étudiant: 1
Nom de l'étudiant: abc
Âge des étudiants: 12

Ainsi, nous avons une classe complète définie ci-dessus. La seule différence notable est que nous avons défini une fonction «print_studentInfo» à l'intérieur de la classe alors que l'autre fonction «read_studentinfo» est définie en dehors de la classe. Ce sont les deux façons dont les fonctions membres peuvent être définies pour une classe.

Notez que la fonction définie à l'extérieur a toujours une déclaration / prototype à l'intérieur de la classe. De plus, il est défini en dehors de la classe à l'aide du opérateur de résolution de portée (: :) . Ensuite, dans la fonction principale, nous créons un objet de classe étudiant, puis nous appelons des fonctions pour lire et afficher les données.

Constructeurs

Jusqu'à présent, dans ce didacticiel, nous avons créé un objet simple, puis nous attribuons des valeurs à chaque membre de données de la classe dans la fonction principale après avoir lu ces valeurs à partir de l'entrée standard.

Dans cette rubrique, nous examinerons une fonction spéciale utilisée pour initialiser l'objet lors de sa création. Cette fonction spéciale est appelée un constructeur.

Un constructeur est une fonction membre de la classe, mais il diffère de la fonction membre normale des manières suivantes:

techniques de test boîte noire avec exemples ppt
  1. Le constructeur n'a pas de valeur de retour, c'est-à-dire que le constructeur ne renvoie jamais de valeur.
  2. C'est une fonction membre public de la classe.
  3. Il est utilisé pour initialiser les données membres et construire l'objet de la classe.
  4. Il est automatiquement appelé par le compilateur lors de la création de l'objet.

Types de constructeurs

C ++ prend en charge les types de constructeurs suivants.

# 1) Constructeur par défaut

Un constructeur par défaut est le constructeur de base et n'a aucun paramètre. Nous pouvons créer un objet simple sans aucun paramètre en utilisant le constructeur par défaut.

Le constructeur par défaut a la syntaxe suivante:

classname() { //constructor code }

Si une classe n'a pas de constructeur par défaut, le compilateur le crée.

# 2) Constructeur paramétré

Un constructeur paramétré est celui qui a une liste de paramètres à l'aide de laquelle nous pouvons initialiser les membres de la classe. Lorsque nous déclarons un objet dans un constructeur paramétré, nous devons transmettre les valeurs initiales à la fonction constructeur en tant que paramètres.

Une fonction constructeur paramétrée ressemble à celle ci-dessous.

classname(argument list){ //constructor code }

Un constructeur paramétré est utilisé pour surcharger les constructeurs. Nous en verrons plus sur la surcharge dans nos rubriques ultérieures.

Un constructeur paramétré est utilisé dans le but d'initialiser les membres de données de différents objets. Ce faisant, nous pouvons transmettre différentes valeurs de membres de données à différents objets.

# 3) Copier les constructeurs

C ++ prend en charge un troisième type de constructeur appelé constructeur de copie. Sa forme générale est

nom de classe (const nom de classe & obj);

Comme indiqué dans la déclaration ci-dessus, dans le constructeur de copie, un nouvel objet est créé en utilisant les valeurs d'un autre objet de la même classe. Le paramètre qui est passé au constructeur est la référence constante d'un objet dont les valeurs seront utilisées pour la construction du nouvel objet.

Un constructeur de copie est généralement appelé dans les situations suivantes:

  1. Lorsqu'un objet de classe est renvoyé par valeur.
  2. Lorsqu'un objet est passé à une fonction en tant qu'argument et est passé par valeur.
  3. Lorsqu'un objet est construit à partir d'un autre objet de la même classe.
  4. Lorsqu'un objet temporaire est généré par le compilateur.

Cependant, nous ne pouvons pas garantir que le constructeur de copie sera sûrement appelé dans tous les cas ci-dessus car le compilateur C ++ a un moyen d'optimiser les opérations de copie.

Un constructeur de copie effectue une copie par membre entre les objets. Tout comme le constructeur par défaut, le compilateur C ++ crée un constructeur de copie par défaut si nous n'en fournissons pas un dans notre programme. Mais lorsqu'une classe a certains membres de données tels que des pointeurs, des références ou toute allocation de ressources à l'exécution, nous devons avoir notre propre constructeur de copie défini par l'utilisateur.

La raison en est que le constructeur de copie par défaut n'effectue qu'une copie superficielle des membres de données, c'est-à-dire que les deux objets partageront le même emplacement mémoire. Cela convient parfaitement aux membres de données simples sans pointeur.

Cependant, en ce qui concerne les pointeurs ou tout autre membre de données dynamiques, nous souhaitons que les données soient pointées vers un nouvel emplacement mémoire. Il s'agit de la copie complète et ne peut être obtenue qu'à l'aide d'un constructeur de copie défini par l'utilisateur.

Ci-dessous un programme C ++ complet qui implémente les trois types de constructeurs et leur utilisation dans la construction d'un objet.

#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; //default constructor student(){ student_id = 1; student_name = 'abc'; student_age = 10; } //parameterized constructor student(int id,string name,int age){ student_id = id; student_name = name; student_age = age; } //copy constructor student(const student& st){ student_id = st.student_id; student_name = st.student_name; student_age = st.student_age; } void print_studentInfo() { cout<<' Student ID : '<

Production:

********** s **********
ID étudiant: 1
Nom de l'étudiant: abc
Âge des étudiants: 10

********** s2 **********
ID étudiant: 2
Nom de l'étudiant: xyz
Âge des étudiants: 12

La capture d'écran pour le même est donnée ci-dessous.

sortie des constructeurs

Dans ce programme, nous avons défini un élève de classe similaire à celui défini dans le programme précédent. La différence est qu'au lieu de lire les valeurs des membres de données à partir d'une entrée standard via une fonction, nous définissons trois constructeurs.

Il est tout à fait possible pour une classe d'avoir plus d'un constructeur. Nous avons un constructeur par défaut qui initialise les données membres aux valeurs initiales. Ensuite, nous définissons un constructeur paramétré qui transmet les valeurs initiales en tant que paramètres au constructeur.

Ensuite, nous définissons un constructeur de copie auquel nous passons une référence constante à un objet de la classe étudiante.

Dans la fonction principale, nous créons trois objets séparément en utilisant trois constructeurs. Le premier objet s est créé à l'aide du constructeur par défaut. Le deuxième objet s1 est créé à l'aide du constructeur paramétré tandis que le troisième objet s2 est créé à l'aide d'un constructeur de copie.

Notez la création du troisième objet s2. Ici, nous affectons l'objet déjà créé s1 au nouvel objet s2. Ainsi, lorsque nous construisons un nouvel objet en utilisant l'objet déjà existant, un constructeur de copie est appelé par le compilateur.

Opérateur d'assignation

Nous pouvons également affecter les valeurs d'un objet à un autre à l'aide d'un opérateur d'affectation (=). Dans ce cas, nous aurons une instruction comme s1 = s.

La différence entre le constructeur de copie et l'opérateur d'affectation est que, tandis que le constructeur de copie construit complètement un nouvel objet, l'opérateur d'affectation affecte simplement les valeurs d'un membre de l'objet sur RHS à celles de l'objet sur LHS. Cela signifie que les objets des deux côtés d'un opérateur d'affectation doivent exister avant l'affectation.

Destroyers

Un destructeur est également une fonction spéciale comme un constructeur, mais il implémente la fonctionnalité qui est exactement opposée au constructeur. Alors que le constructeur est utilisé pour créer un objet, un destructeur est utilisé pour détruire ou supprimer un objet.

Certaines des caractéristiques du destructeur comprennent:

  • Un nom de destructeur est le même que le nom de classe mais commence par un signe tilde (~).
  • Destructor n'a pas de type de retour.
  • Un destructeur n'a aucun argument.
  • Il ne peut y avoir qu'un seul destructeur dans une classe.
  • Le compilateur crée toujours un destructeur par défaut si nous ne parvenons pas à en fournir un pour une classe.

La syntaxe générale d'un destructeur est:

~classname(){ //cleanup code }

Le destructeur d'une classe est généralement appelé dans les situations suivantes:

  1. Lorsque l'objet sort de la portée, le destructeur de classe est automatiquement appelé.
  2. De même, le destructeur est appelé lorsque le programme termine l'exécution. Cela signifie que tous les objets cessent également d'exister. Par conséquent, le destructeur de chaque objet sera appelé.
  3. Le destructeur de la classe est également appelé lorsque l’opérateur ‘delete’ pour supprimer un objet est exécuté.
  4. Nous pouvons également appeler le destructeur explicitement pour effectuer toutes les activités de nettoyage une fois que nous en avons terminé avec la fonctionnalité d'objet.

L'exemple donné ci-dessous illustre le fonctionnement d'un destructeur.

#include using namespace std; class sample{ public: sample(){ cout<<'Constructor::sample called'<

Production:

Constructor :: sample appelé

Ceci est un exemple de classe

Destructor :: ~ exemple appelé

La capture d'écran de la sortie ci-dessus est donnée ci-dessous.

sortie du destructeur

Nous avons défini un exemple de classe dans lequel nous avons défini un constructeur, un destructeur et un affichage de fonction. Dans la fonction principale, nous créons un objet obj de classe sample puis appelons la fonction d'affichage sur cet objet.

Après cela, un retour 0 est exécuté. Dans la sortie, nous pouvons voir que le moment où la fonction d'affichage revient et que le contrôle du programme arrive à l'instruction return 0, le destructeur est exécuté. Cela signifie qu'il est exécuté au moment où l'objet sort de la portée.

'Ce' pointeur

C ++ utilise un concept spécial lié aux objets, appelé pointeur «this». Le pointeur «this» pointe toujours vers l'objet courant. Ainsi selon la situation, chaque fois que nous devons nous référer à l'objet courant, nous utilisons le pointeur «this».

Nous savons que chaque fois qu'une instance de la classe, c'est-à-dire un objet, est créée, une copie séparée des données membres de la classe est créée pour l'objet. Mais en ce qui concerne les fonctions membres de la classe, tous les objets partagent la même copie.

Ainsi, lorsqu'un ou plusieurs objets accèdent simultanément aux fonctions membres, comment pouvons-nous nous assurer que les données membres appropriées sont accédées et modifiées par les fonctions membres?

C'est ici que «ce» pointeur entre en action. Le compilateur passe un pointeur implicite avec le nom de la fonction comme «this». C'est ce qu'on appelle le pointeur «this».

Le pointeur «this» est passé comme argument masqué à tous les appels de fonction membre. Il s'agit généralement d'une variable locale. Par conséquent, «ce» pointeur est un pointeur constant et son contenu est l'adresse mémoire de l'objet courant.

Notez que ce pointeur n'est disponible que pour les fonctions membres non statiques et non pour les fonctions statiques. En effet, les fonctions statiques n'ont pas besoin d'être accédées à l'aide d'un objet. Ils sont directement accessibles en utilisant le nom de la classe.

Nous utilisons généralement le pointeur «this» dans les situations où les variables membres et les paramètres sont passés pour initialiser les variables membres qui partagent le même nom. Nous l'utilisons également lorsque nous devons renvoyer l'objet courant à partir de la fonction.

Voyons la démonstration de «ce» pointeur ci-dessous.

#include using namespace std; class Sample { private: int num; char ch; public: Sample &setParam(int num, char ch){ this->num =num; this->ch = ch; return *this; } void printValues(){ cout<<'num = '<

Production:

num = 100
ch = A

Dans le programme ci-dessus, nous avons une classe appelée Sample, avec deux membres de données num et ch. Nous avons une fonction membre setParam qui transmet les paramètres avec les mêmes noms, num et ch pour définir les valeurs des variables membres.

À l'intérieur de la fonction, nous affectons ces valeurs aux variables de membre de l'objet actuel indiquées par ce pointeur. Une fois les valeurs définies, l'objet courant «this» est renvoyé par la fonction.

Dans la fonction principale, nous créons d'abord un objet de la classe Sample, obj et appelons une fonction setParam pour définir les valeurs, puis appelons la fonction printValues ​​pour imprimer les valeurs.

Conclusion

Nous avons appris les éléments de base de la POO en C ++ dans ce didacticiel. Comprendre les classes et les objets est la principale exigence, pour commencer, la POO en C ++. Nous avons également appris les constructeurs et les destructeurs en détail avec des exemples.

Dans notre prochain didacticiel, nous découvrirons les listes d'initialiseurs en C ++.

=> Regardez la série de formations C ++ simple ici.

meilleur endroit pour regarder des anime gratuitement

lecture recommandée

^