Introduction aux classes et objets C ++

Objets sont la plus grande différence entre C ++ et C. L'un des premiers noms de C ++ était C with Classes.

Une classe est une définition d'un objet. C'est un type comme int. Une classe ressemble à un struct avec une seule différence: tous les membres de la structure sont publics par défaut. Tous les membres des classes sont privés.

N'oubliez pas - une classe est un type et un objet de cette classe n'est qu'un variable.

Avant de pouvoir utiliser un objet, il doit être créé. La définition la plus simple d'une classe est:

 nom du cours {

 // membres

 }

Cet exemple de classe ci-dessous modélise un livre simple. L'utilisation de la POO vous permet d'abstraire le problème et d'y réfléchir et pas seulement des variables arbitraires.

 // exemple un

 #comprendre 

 #comprendre 

 livre de classe

 {

 int PageCount;

 int CurrentPage; 

 Publique:

 Livre (int Numpages); // Constructeur

 ~ Livre () {}; // Destructeur

 void SetPage (int PageNumber);

 int GetCurrentPage (void);

 }; 

 Book:: Book (int NumPages) {

 PageCount = NumPages;

 }

 void Book:: SetPage (int PageNumber) {

 CurrentPage = PageNumber;

 }

 int Book:: GetCurrentPage (void) {

 return CurrentPage;

 }

 int main() {

 Livre ABook (128);

 Un livre. SetPage (56);

 std:: cout << "Page actuelle" << ABook. GetCurrentPage () << std:: endl;

 retourner 0;

 }

Tout le code de livre de classe jusqu'au int Book:: GetCurrentPage (void) { La fonction fait partie de la classe. le principale() est là pour en faire une application exécutable.

dans le principale() une variable ABook de type Book est créée avec la valeur 128. Dès que l'exécution atteint ce point, l'objet ABook est construit. Sur la ligne suivante, la méthode Un livre. Mettre en place la page() est appelé et la valeur 56 attribuée à la variable objet Un livre. Page actuelle. alors cout renvoie cette valeur en appelant la Un livre. GetCurrentPage () méthode.

Lorsque l'exécution atteint le retourner 0; l'objet ABook n'est plus nécessaire à l'application. Le compilateur génère un appel au destructeur.

Tout entre Livre de classe et le } est la déclaration de classe. Cette classe a deux membres privés, tous deux de type int. Celles-ci sont privées car l'accès par défaut aux membres de la classe est privé.

le Publique: indique à la compilateur qui accède à partir d'ici est public. Sans cela, il resterait privé et empêcherait les trois lignes de la fonction main () d'accéder aux membres Abook. Essayez de commenter le Publique: ligne et recompilation pour voir les erreurs de compilation qui s'ensuivent.

Cette ligne ci-dessous déclare un constructeur. Il s'agit de la fonction appelée lors de la première création de l'objet.

 Livre (int Numpages); // Constructeur 

Il est appelé depuis la ligne

 Livre ABook (128); 

Cela crée un objet appelé ABook de type Book et appelle la fonction Book () avec le paramètre 128.

En C ++, le constructeur a toujours le même nom que la classe. Le constructeur est appelé lorsque l'objet est créé et c'est là que vous devez mettre votre code pour initialiser l'objet.

Dans le livre La ligne suivante après le constructeur le destructeur. Celui-ci porte le même nom que le constructeur mais avec un ~ (tilde) devant. Lors de la destruction d'un objet, le destructeur est appelé pour ranger l'objet et s'assurer que les ressources telles que la mémoire et le descripteur de fichier utilisé par l'objet sont libérées.

Rappelles toi—Une classe xyz a une fonction constructeur xyz () et une fonction destructrice ~ xyz (). Même si vous ne déclarez pas, le compilateur les ajoutera en silence.

Le destructeur est toujours appelé lorsque l'objet est terminé. Dans cet exemple, l'objet est implicitement détruit lorsqu'il sort de la portée. Pour voir cela, modifiez la déclaration du destructeur en ceci:

 ~ Book () {std:: cout << "Destructeur appelé";}; // Destructeur 

Il s'agit d'une fonction en ligne avec du code dans la déclaration. Une autre façon d'inline est d'ajouter le mot inline

 en ligne ~ Book (); // Destructeur

et ajoutez le destructeur comme une fonction comme celle-ci.

 Livre en ligne:: ~ Livre (vide) { 

 std:: cout << "Destructeur appelé";

 }

Les fonctions en ligne sont des astuces pour le compilateur pour générer du code plus efficace. Ils ne doivent être utilisés que pour de petites fonctions, mais s'ils sont utilisés dans des endroits appropriés, comme à l'intérieur boucles—Peut faire une différence considérable dans les performances.

Meilleur entrainement pour les objets consiste à rendre toutes les données privées et à y accéder via des fonctions appelées fonctions d'accesseur. Mettre en place la page() et GetCurrentPage () sont les deux fonctions utilisées pour accéder à la variable objet Page actuelle.

Changer la classe déclaration pour structurer et recompiler. Il devrait toujours compiler et fonctionner correctement. Maintenant, les deux variables Nombre de pages et Page actuelle sont accessibles au public. Ajoutez cette ligne après le livre ABook (128), et elle se compilera.

 Un livre. PageCount = 9;

Si vous revenez à struct classe et recompiler, cette nouvelle ligne ne compilera plus comme Nombre de pages est à nouveau privé.

Après le corps de la déclaration de classe de livre, il y a les quatre définitions des fonctions membres. Chacun est défini avec le préfixe Book:: pour l'identifier comme appartenant à cette classe.:: est appelé l'identificateur de portée. Il identifie la fonction comme faisant partie de la classe. C'est évident dans la déclaration de classe mais pas en dehors.

Si vous avez déclaré une fonction membre dans une classe, vous devez fournir le corps de la fonction de cette manière. Si vous souhaitez que la classe Book soit utilisée par d'autres fichiers, vous pouvez déplacer la déclaration de livre dans un fichier séparé entête fichier, peut-être appelé book.h. Tout autre fichier pourrait alors l'inclure avec

 #include "book.h" 

Cet exemple montrera l'héritage. Il s'agit d'une application à deux classes avec une classe dérivée d'une autre.

 #comprendre 

 #comprendre 

 classe Point

 {

 int x, y;

 Publique:

 Point (int atx, int aty); // Constructeur

 virtuel en ligne ~ Point (); // Destructeur

 vide virtuel Draw ();

 }; 

 Cercle de classe: Point public {

 rayon int;

 Publique:

 Cercle (int atx, int aty, int theRadius);

 virtuel en ligne ~ Circle ();

 vide virtuel Draw ();

 };

 Point:: Point (int atx, int aty) {

 x = atx;

 y = aty;

 }

 inline Point:: ~ Point (void) { 

 std:: cout << "Point Destructor appelé";

 }

 void Point:: Draw (void) {

 std:: cout << "Point:: Dessine le point à" << x << "" << y << std:: endl;

 }

 Circle:: Circle (int atx, int aty, int theRadius): Point (atx, aty) {

 radius = theRadius;

 }

 Cercle en ligne:: ~ Cercle () {

 std:: cout << "Circle Destructor appelé" << std:: endl;

 }

 void Circle:: Draw (void) {

 Point:: Draw ();

 std:: cout << "circle:: Draw point" << "Radius" << radius << std:: endl;

 }

 int main() {

 Cercle ACircle (10,10,5);

 Un cercle. Dessiner() ;

 retourner 0;

 }

L'exemple a deux classes, Point et Circle, modélisant un point et un cercle. Un point a des coordonnées x et y. La classe Circle est dérivée de la classe Point et ajoute un rayon. Les deux classes comprennent un Dessiner() fonction membre. Pour garder cet exemple court, la sortie est juste du texte.

La classe Cercle est dérivé du Point classe. Cela se fait dans cette ligne:

 Cercle de classe: Point {

Puisqu'il est dérivé d'une classe de base (Point), Circle hérite de tous les membres de la classe.

 Point (int atx, int aty); // Constructeur

 virtuel en ligne ~ Point (); // Destructeur

 vide virtuel Draw ();

 Cercle (int atx, int aty, int theRadius);

 virtuel en ligne ~ Circle ();

 vide virtuel Draw ();

Considérez la classe Circle comme la classe Point avec un membre supplémentaire (rayon). Il hérite des fonctions membres et des variables privées de la classe de base X et y.

Il ne peut pas les attribuer ou les utiliser, sauf implicitement parce qu'ils sont privés, il doit donc le faire via la liste Initializer du constructeur Circle. C'est quelque chose que vous devez accepter tel quel pour l'instant. Je reviendrai sur les listes d'initialisation dans un futur tutoriel.

Dans le Circle Constructor, avant le rayon est affecté au rayon, la partie Point de Circle est construite via un appel au constructeur de Point dans la liste d'initialisation. Cette liste est tout entre le: et le {ci-dessous.

 Cercle:: Cercle (int atx, int aty, int theRadius): Point (atx, aty) 

Par ailleurs, l'initialisation du type constructeur peut être utilisée pour tous les types intégrés.

 int a1 (10);

 int a2 = 10;

Les deux font de même.

Le polymorphisme est un terme générique qui signifie «plusieurs formes». En C ++, la forme la plus simple de polymorphisme est la surcharge de fonctions. Par exemple, plusieurs fonctions appelées SortArray (arraytype) où sortarray pourrait être un tableau de pouces ou double.

Cependant, nous ne sommes intéressés que par la forme OOP du polymorphisme. Cela se fait en créant une fonction (par exemple Draw ()) virtuel dans la classe de base Point, puis la remplacer dans le Classe dérivée Cercle.

Bien que la fonction Dessiner() est virtuel dans la classe dérivée Cercle, ce n'est pas vraiment nécessaire - c'est juste un rappel pour moi que c'est virtuel. Si la fonction d'une classe dérivée correspond à une fonction virtuelle de la classe de base sur les types de nom et de paramètre, elle est automatiquement virtuelle.

Dessiner un point et dessiner un cercle sont deux opérations très différentes avec seulement les coordonnées du point et du cercle en commun, il est donc important que la bonne Dessiner() est appelé. La façon dont le compilateur parvient à générer du code qui obtient la bonne fonction virtuelle sera traitée dans un futur tutoriel.

Un constructeur est une fonction qui initialise les membres d'un objet. Un constructeur ne sait que construire un objet de sa propre classe.

Les constructeurs ne sont pas automatiquement hérités entre la classe de base et les classes dérivées. Si vous n'en fournissez pas dans la classe dérivée, une valeur par défaut sera fournie, mais cela peut ne pas faire ce que vous voulez.

Si aucun constructeur n'est fourni, un constructeur par défaut est créé par le compilateur sans aucun paramètre. Il doit toujours y avoir un constructeur, même s'il est par défaut et vide. Si vous fournissez un constructeur avec des paramètres, un défaut ne sera PAS créé.

Quelques points sur les constructeurs:

• Les constructeurs ne sont que des fonctions du même nom que la classe.
• Les constructeurs sont destinés à initialiser les membres de la classe lorsqu'une instance de cette classe est créée.
• Les constructeurs ne sont pas appelés directement (sauf via les listes d'initialisation)
• Les constructeurs ne sont jamais virtuels.
• Plusieurs constructeurs pour la même classe peuvent être définis. Ils doivent avoir des paramètres différents pour les distinguer.

Il y a beaucoup plus à apprendre sur les constructeurs, par exemple, les constructeurs par défaut, les constructeurs d'affectation et de copie. Celles-ci seront discutées dans la prochaine leçon.

Un destructeur est une fonction membre de classe qui porte le même nom que le constructeur (et la classe) mais avec un ~ (tilde) devant.

 ~ Cercle ();

Lorsqu'un objet est hors de portée ou plus rarement est explicitement détruit, son destructeur est appelé. Par exemple, si l'objet a des variables dynamiques telles que des pointeurs, celles-ci doivent être libérées et le destructeur est l'endroit approprié.

Contrairement aux constructeurs, les destructeurs peuvent et doivent être rendus virtuels si vous avez des classes dérivées. dans le Point et Cercle exemple de classes, le destructeur n'est pas nécessaire car il n'y a pas de travail de nettoyage à faire (il sert juste d'exemple). Y avait-il eu des variables membres dynamiques (comme pointeurs), il aurait fallu les libérer pour éviter les fuites de mémoire.

De plus, lorsque la classe dérivée ajoute des membres qui nécessitent un nettoyage, des destructeurs virtuels sont nécessaires. Lorsqu'il est virtuel, le destructeur de classe le plus dérivé est appelé en premier, puis le destructeur de son ancêtre immédiat est appelé, et ainsi de suite jusqu'à la classe de base.

Dans notre exemple,

 ~ Cercle ();

ensuite

 ~ Point ();

Le destructeur des classes de base est appelé en dernier.

Ceci termine cette leçon. Dans la leçon suivante, découvrez les constructeurs par défaut, les constructeurs de copie et l'affectation.