Cours en C++ est la pierre angulaire de la programmation orientée objet. Il s'agit d'un type de données défini par l'utilisateur, qui contient ses propres données membres et fonctions membres, accessibles et utilisées en créant une instance de cette classe. Une classe C++ est comme un modèle pour un objet. Par exemple : considérons la classe de Voitures . Il peut y avoir de nombreuses voitures avec des noms et des marques différents, mais elles partageront toutes des propriétés communes. 4 roues , Limitation de vitesse , Plage de kilométrage, etc. Donc ici, Car est la classe, et les roues, les limites de vitesse et le kilométrage sont leurs propriétés.
- Une classe est un type de données défini par l'utilisateur qui comporte des données membres et des fonctions membres.
- Les données membres sont les variables de données et les fonctions membres sont les fonctions utilisées pour manipuler ces variables ensemble, ces données membres et fonctions membres définissent les propriétés et le comportement des objets dans une classe.
- Dans l'exemple de classe ci-dessus Voiture , le membre de données sera Limitation de vitesse , kilométrage, etc, et les fonctions membres peuvent être appliquer les freins , vitesse croissante, etc.
Un Objet est une instance d'une classe. Lorsqu'une classe est définie, aucune mémoire n'est allouée mais lorsqu'elle est instanciée (c'est-à-dire qu'un objet est créé), la mémoire est allouée.
Définir une classe et déclarer des objets
Une classe est définie en C++ à l'aide du mot-clé class suivi du nom de la classe. Le corps de la classe est défini entre accolades et terminé par un point-virgule à la fin.
Déclaration d'objets
Lorsqu'une classe est définie, seule la spécification de l'objet est définie ; aucune mémoire ou stockage n’est alloué. Pour utiliser les données et les fonctions d'accès définies dans la classe, vous devez créer des objets.
Syntaxe
ClassName ObjectName;>
Accès aux données membres et aux fonctions membres : Les données membres et les fonctions membres de la classe sont accessibles à l'aide de l'opérateur point('.') avec l'objet. Par exemple, si le nom de l'objet est obj et vous souhaitez accéder à la fonction membre avec le nom printName() alors tu devras écrire obj.printName() .
Accès aux membres de données
Les membres de données publiques sont également accessibles de la même manière, mais les membres de données privées ne sont pas autorisés à accéder directement par l'objet. L’accès à un membre de données dépend uniquement du contrôle d’accès de ce membre de données. Ce contrôle d'accès est donné par les modificateurs d'accès en C++. Il existe trois modificateurs d'accès : public, privé et protégé .
C++
opérateurs Java
// C++ program to demonstrate accessing of data members> #include> using> namespace> std;> class> Geeks {> >// Access specifier> public>:> >// Data Members> >string geekname;> >// Member Functions()> >void> printname() { cout <<>'Geekname is:'> << geekname; }> };> int> main()> {> >// Declare an object of class geeks> >Geeks obj1;> >// accessing data member> >obj1.geekname =>'Abhi'>;> >// accessing member function> >obj1.printname();> >return> 0;> }> |
>
>Sortir
Geekname is:Abhi>
Fonctions membres dans les classes
Il existe 2 manières de définir une fonction membre :
- Définition de la classe intérieure
- Définition de classe hors classe
Pour définir une fonction membre en dehors de la définition de classe, nous devons utiliser le résolution de portée : opérateur ainsi que le nom de la classe et le nom de la fonction.
C++
tri par sélection
// C++ program to demonstrate function> // declaration outside class> > #include> using> namespace> std;> class> Geeks> {> >public>:> >string geekname;> >int> id;> > >// printname is not defined inside class definition> >void> printname();> > >// printid is defined inside class definition> >void> printid()> >{> >cout <<>'Geek id is: '>< } }; // Definition of printname using scope resolution operator :: void Geeks::printname() { cout <<'Geekname is: '< } int main() { Geeks obj1; obj1.geekname = 'xyz'; obj1.id=15; // call printname() obj1.printname(); cout << endl; // call printid() obj1.printid(); return 0; }> |
>
>Sortir
Geekname is: xyz Geek id is: 15>
Notez que toutes les fonctions membres définies dans la définition de classe sont par défaut en ligne , mais vous pouvez également intégrer n'importe quelle fonction non-classe en utilisant le mot-clé inline avec elles. Les fonctions en ligne sont des fonctions réelles, qui sont copiées partout lors de la compilation, comme les macros du pré-processeur, de sorte que la surcharge des appels de fonction est réduite.
Note: Déclarer un fonction ami est un moyen de donner un accès privé à une fonction non membre.
Constructeurs
Constructeurs sont des membres de classe spéciaux qui sont appelés par le compilateur chaque fois qu'un objet de cette classe est instancié. Les constructeurs portent le même nom que la classe et peuvent être définis à l'intérieur ou à l'extérieur de la définition de la classe. Il existe 3 types de constructeurs :
- Constructeurs par défaut
- Constructeurs paramétrés
- Copier les constructeurs
C++
langage informatique génial
// C++ program to demonstrate constructors> #include> using> namespace> std;> class> Geeks> {> >public>:> >int> id;> > >//Default Constructor> >Geeks()> >{> >cout <<>'Default Constructor called'> << endl;> >id=-1;> >}> > >//Parameterized Constructor> >Geeks(>int> x)> >{> >cout <<>'Parameterized Constructor called '><< endl;> >id=x;> >}> };> int> main() {> > >// obj1 will call Default Constructor> >Geeks obj1;> >cout <<>'Geek id is: '>< // obj2 will call Parameterized Constructor Geeks obj2(21); cout <<'Geek id is: ' < return 0; }> |
>
>Sortir
Default Constructor called Geek id is: -1 Parameterized Constructor called Geek id is: 21>
UN Copier le constructeur crée un nouvel objet, qui est une copie exacte de l'objet existant. Le compilateur fournit un constructeur de copie par défaut à toutes les classes.
Syntaxe:
class-name (class-name &){}> destroyers
Destructeur est une autre fonction membre spéciale appelée par le compilateur lorsque la portée de l'objet se termine.
C++
// C++ program to explain destructors> #include> using> namespace> std;> class> Geeks> {> >public>:> >int> id;> > >//Definition for Destructor> >~Geeks()> >{> >cout <<>'Destructor called for id: '> << id < } }; int main() { Geeks obj1; obj1.id=7; int i = 0; while ( i <5 ) { Geeks obj2; obj2.id=i; i++; } // Scope for obj2 ends here return 0; } // Scope for obj1 ends here> |
>
bases du sélénium
>Sortir
Destructor called for id: 0 Destructor called for id: 1 Destructor called for id: 2 Destructor called for id: 3 Destructor called for id: 4 Destructor called for id: 7>
Fait intéressant (concept rare connu)
Pourquoi donne-t-on des points-virgules à la fin du cours ?
Beaucoup de gens pourraient dire qu’il s’agit d’une syntaxe de base et que nous devrions mettre un point-virgule à la fin de la classe comme le définit sa règle dans cpp. Mais la principale raison pour laquelle des points-virgules sont présents à la fin de la classe est que le compilateur vérifie si l'utilisateur essaie de créer une instance de la classe à la fin de celle-ci.
Oui tout comme la structure et l'union, on peut aussi créer l'instance d'une classe à la fin juste avant le point-virgule. Par conséquent, une fois que l’exécution atteint cette ligne, elle crée une classe et alloue de la mémoire à votre instance.
C++
#include> using> namespace> std;> > class> Demo{> >int> a, b;> >public>:> >Demo()>// default constructor> >{> >cout <<>'Default Constructor'> << endl;> >}> >Demo(>int> a,>int> b):a(a),b(b)>//parameterised constructor> >{> >cout <<>'parameterized constructor -values'> << a <<>' '><< b << endl;> >}> > }instance;> > > int> main() {> > >return> 0;> }> |
>
>Sortir
Default Constructor>
Nous pouvons voir que nous avons créé une instance de classe de Demo avec le nom instance, par conséquent, la sortie que nous pouvons voir est que le constructeur par défaut est appelé.
De même, nous pouvons également appeler le constructeur paramétré simplement en passant des valeurs ici
C++
#include> using> namespace> std;> > class> Demo{> >public>:> >int> a, b;> >Demo()> >{> >cout <<>'Default Constructor'> << endl;> >}> >Demo(>int> a,>int> b):a(a),b(b)> >{> >cout <<>'parameterized Constructor values-'> << a <<>' '><< b << endl;> >}> > > > }instance(100,200);> > > int> main() {> > >return> 0;> }> |
>
>
commande de retour javaSortir
parameterized Constructor values-100 200>
Ainsi en créant une instance juste avant le point-virgule, on peut créer l'instance de classe.
Articles Liés:
- Héritage multiple en C++
- Destructeur virtuel pur
- Quiz C++