Dans ce guide, nous examinerons les opérateur double-virgule (::) en C++ et comment cela fonctionne dans différents scénarios.
Qu'est-ce que :: Do en C++ ?
En C++, le résolution de portée opérateur (::) permet de récupérer les noms de variables présents à différents niveaux de portée. La portée de la programmation fait référence au contexte dans lequel les variables et les fonctions sont accessibles.
Utilisations de :: dans différents cas en C++
En C++, le opérateur de résolution de portée (::) a diverses utilisations selon le contexte dans lequel il est utilisé. Voici quelques utilisations notables de cet opérateur :
1 : Accéder à une variable ou à une fonction dans un espace de noms différent
UN espace de noms est utilisé en C++ pour regrouper des fonctions, des classes et des variables associées afin d'éviter les conflits de nommage. Lorsque vous définissez une variable ou une fonction dans un espace de noms , le nom de la variable ou de la fonction n'est visible que dans ce espace de noms .
En C++, vous pouvez utiliser le opérateur de résolution de portée (::) avec le espace de noms name et le nom de la variable ou de la fonction pour accéder à une variable ou une fonction définie dans un espace de noms différent. Cela vous permet d'accéder à la variable ou à la fonction à partir d'un espace de noms autre que celui dans lequel il a été créé.
Pour comprendre le cas ci-dessus, considérons le code suivant comme exemple :
#includeen utilisant l'espace de noms std ;
mathématiques de l'espace de noms {
constante double PI = 3.14159 ;
double carré ( double X ) {
retour X * X ;
}
}
entier principal ( ) {
cout << 'La valeur de PI est : ' << mathématiques :: PI << fin ;
cout << « Le carré de 5 est : » << mathématiques :: carré ( 5 ) << fin ;
retour 0 ;
}
Le code ci-dessus utilise le espace de noms mathématique pour accéder à la 'PI' constante et 'carré' fonction à l'aide de la opérateur de résolution de portée ' :: ' . Il imprime ensuite les valeurs sur la console.
Sortir
2 : Accéder à la variable globale dans le programme
Lorsque le même nom de variables locales et globales est présent dans le programme, la variable locale peut masquer la variable globale. Dans de telles situations, vous pouvez utiliser le opérateur de résolution de portée (::) pour accéder à la variable globale. Cet opérateur nous permet de faire explicitement référence à la variable globale en fonction de sa portée.
Par exemple, dans le code ci-dessous, nous avons fait référence à la variable globale 'un ' via le opérateur de résolution de portée (::) , depuis l'intérieur d'une fonction où une variable locale portant le même nom a été définie :
#includeen utilisant l'espace de noms std ;
entier un = quinze ;
entier principal ( )
{
entier un = 35 ;
cout << 'La valeur de la variable globale a est' << :: un << fin ;
cout << 'La valeur de la variable locale a est' << un << fin ;
retour 0 ;
}
Dans le code ci-dessus, la variable a présente en dehors de la fonction principale est la variable globale et la variable a dans la fonction principale est la variable locale avec le même nom que la variable globale. Dans l'instruction cout, nous avons utilisé l'opérateur de résolution de portée pour imprimer la variable globale un .
Sortir
3 : Définir une fonction en dehors de la classe
En C++, vous pouvez définir une fonction de classe en dehors de la définition de classe et cela peut être fait en utilisant le opérateur de résolution de portée (::) pour spécifier à quelle classe appartient la fonction. Cela est nécessaire car la fonction est définie en dehors de la portée de la classe.
Voici un exemple de code qui illustre cette utilisation du opérateur de résolution de portée :
#includeen utilisant l'espace de noms std ;
classe maclasse {
public :
annuler mafonction ( ) ;
} ;
annuler Ma classe :: mafonction ( ) {
cout << 'mafonction() Appelée !' ;
}
entier principal ( )
{
maclasse classObj ;
classObj. mafonction ( ) ;
retour 0 ;
}
Dans le code ci-dessus, la fonction membre mafonction() est défini en dehors de la classe à l'aide de la opérateur de résolution de portée :: pour préciser que mafonction() appartient à la classe myClass.
Sortir
4 : Accéder aux membres statiques de la classe
En C++, lorsqu'il y a un membre statique et qu'une variable locale portant le même nom est présente dans la classe, le opérateur de résolution de portée (::) peut être utilisé pour accéder aux membres statiques d'une classe. Cela permet au programme de faire la distinction entre la variable locale et le membre statique.
Voici un exemple de code qui concerne l'utilisation de opérateur de résolution de portée pour un tel cas :
#includeen utilisant l'espace de noms std ;
classe maclasse {
public :
statique entier maVarStat ;
} ;
entier Ma classe :: maVarStat = 5 ;
entier principal ( ) {
entier maVarStat = dix ;
cout << 'Variable locale myStatVar : ' << maVarStat << fin ;
cout << 'Variable de classe myStatVar : ' << Ma classe :: maVarStat << fin ;
retour 0 ;
}
Le programme ci-dessus définit d'abord une classe Ma classe avec une variable de membre statique maVarStat . Il définit ensuite une variable locale portant le même nom à l'intérieur de la fonction principale du programme. Pour accéder à la variable de classe, le opérateur de résolution de portée (::) est utilisé avec le nom de la classe Ma classe . Le programme envoie la valeur des deux variables à la console.
Sortir
5 : Utiliser avec plusieurs héritages
Le opérateur de résolution de portée (::) est également utilisé pour indiquer la version d'un membre à utiliser lorsqu'une classe C++ est dérivée de plusieurs classes parentes qui ont des variables membres ou des fonctions portant le même nom. Nous pouvons distinguer différentes versions d'un même membre en utilisant le opérateur de résolution de portée suivi du nom de la classe parente et du nom du membre.
#includeen utilisant l'espace de noms std ;
classe Parent1 {
public :
annuler imprimer ( ) {
cout << 'Il s'agit de la fonction d'impression de la classe Parent1.' << fin ;
}
} ;
classe Parent2 {
public :
annuler imprimer ( ) {
cout << 'Il s'agit de la fonction d'impression de la classe Parent2.' << fin ;
}
} ;
classe maclasse : public Parent1 , public Parent2 {
privé :
entier sur une ;
public :
Ma classe ( entier n ) {
sur une = n ;
}
annuler imprimer ( ) {
Parent1 :: imprimer ( ) ; // appelle la fonction d'impression de Parent1
Parent2 :: imprimer ( ) ; // appelle la fonction d'impression de Parent2
cout << 'La valeur de num est : ' << sur une << fin ; // affiche la valeur de num
}
} ;
entier principal ( ) {
maclasse obj ( 42 ) ; // crée un objet de MyClass avec num initialisé à 42
obj. imprimer ( ) ; // appelle la fonction print() de l'objet
retour 0 ;
}
Le programme ci-dessus montre l'utilisation de la opérateur de résolution de portée (::) distinguer les fonctions d'impression de Parent1 et Parent2 lorsque les deux classes sont héritées par Ma classe. En appelant les fonctions avec le Classe mère name précédant le nom de la fonction, nous pouvons spécifier la version de la fonction à utiliser.
Sortir
Conclusion
Le opérateur de résolution de portée (::) est un composant essentiel en C++ utilisé pour accéder aux noms de variables à différents niveaux de portée. L'opérateur a diverses utilisations, notamment l'accès à une variable ou à une fonction dans un espace de noms différent, l'accès à une variable globale, la définition d'une fonction en dehors de la classe, l'accès aux membres statiques d'une classe et l'utilisation de plusieurs héritages. Bien que cela puisse être déroutant pour les nouveaux développeurs, comprendre le opérateur de résolution de portée (::) est essentiel pour une bonne pratique de programmation.