logo

TechCodeview

Espace de noms en C++ | Ensemble 1 (Introduction)

  • L'espace de noms fournit l'espace où nous pouvons définir ou déclarer un identifiant, c'est-à-dire une variable, une méthode, des classes.
  • En utilisant l'espace de noms, vous pouvez définir l'espace ou le contexte dans lequel les identifiants sont définis, c'est-à-dire variable, méthode, classes. Essentiellement, un espace de noms définit une portée.

Avantage de Namespace pour éviter les collisions de noms.

  • Par exemple, vous écrivez peut-être du code qui a une fonction appelée xyz() et il existe une autre bibliothèque disponible qui a également la même fonction xyz(). Désormais, le compilateur n'a aucun moyen de savoir à quelle version de la fonction xyz() vous faites référence dans votre code.
  • Un espace de noms est conçu pour surmonter cette difficulté et est utilisé comme information supplémentaire pour différencier des fonctions, classes, variables, etc. similaires portant le même nom disponible dans différentes bibliothèques.
  • Le meilleur exemple de portée d’espace de noms est la bibliothèque standard C++ (std) où toutes les classes, méthodes et modèles sont déclarés. Par conséquent, lors de l'écriture d'un programme C++, nous incluons généralement la directive utilisant l'espace de noms std ;

Définir un espace de noms :

  • Une définition d'espace de noms commence par le mot-clé namespace suivi du nom de l'espace de noms comme suit :
namespace namespace_name { // code declarations i.e. variable (int a;) method (void add();) classes ( class student{};) }>
  • Il est à noter qu’il n’y a pas de point-virgule (;) après l’accolade fermante.
  • Pour appeler la version compatible avec l'espace de noms d'une fonction ou d'une variable, ajoutez le nom de l'espace de noms comme suit :
  • nom_espace de noms : :code; // le code peut être une variable, une fonction ou une classe.

La directive using :

  • Vous pouvez également éviter de pré-ajouter des espaces de noms avec la directive using namespace. Cette directive indique au compilateur que le code suivant utilise des noms dans l'espace de noms spécifié.
  • L'espace de noms est donc implicite pour le code suivant :

C++








#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> 

>



>

Sortir 

Inside first_space>
  • Les noms introduits dans une directive using obéissent aux règles de portée normales. Le nom est visible du point de la directive using jusqu'à la fin de la portée dans laquelle se trouve la directive. Les entités portant le même nom définies dans une portée externe sont masquées.

Espaces de noms imbriqués :

  • Les espaces de noms peuvent être imbriqués où vous pouvez définir un espace de noms dans un autre espace de noms comme suit :
SYNTAX: namespace namespace_name1 { // code declarations namespace namespace_name2 { // code declarations } }>

Vous pouvez accéder aux membres d'un espace de noms imbriqué à l'aide des opérateurs de résolution comme suit :
// pour accéder aux membres de namespace_name2
en utilisant l'espace de noms namespace_name1::namespace_name2 ;
// pour accéder aux membres de namespace_name1
en utilisant l'espace de noms namespace_name1 ;

Dans les instructions ci-dessus, si vous utilisez namespace_name1, les éléments de namespace_name2 seront disponibles dans la portée comme suit :

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> >// This calls function from second name space.> >func();> > >return> 0;> }> 

>

>

Sortir 

Inside second_space>

Voyons comment l'espace de noms étend la portée des entités, y compris les variables et les fonctions :

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space :: func();> >// Calls function from second name space.> >second_space :: func();> >return> 0;> }> 

>

>

Sortir 

Inside first_space Inside second_space>

Considérez le programme C++ suivant :

RPC




// A program to demonstrate need of namespace> int> main()> {> >int> value;> >value = 0;> >double> value;>// Error here> >value = 0.0;> }> 

>

>

Sortir :

Compiler Error: 'value' has a previous declaration as 'int value'>

Dans chaque périmètre, un nom ne peut représenter qu'une seule entité. Ainsi, il ne peut pas y avoir deux variables portant le même nom dans la même portée. À l'aide d'espaces de noms, nous pouvons créer deux variables ou fonctions membres portant le même nom.

RPC




// Here we can see that more than one variables> // are being used without reporting any error.> // That is because they are declared in the> // different namespaces and scopes.> #include> using> namespace> std;> // Variable created inside namespace> namespace> first {> int> val = 500;> }> // Global variable> int> val = 100;> int> main()> {> >// Local variable> >int> val = 200;> >// These variables can be accessed from> >// outside the namespace using the scope> >// operator ::> >cout << first::val <<>' '>;> >return> 0;> }> 

>

>

Sortir 

500>

Définition et création : Les espaces de noms nous permettent de regrouper des entités nommées qui autrement auraient portée mondiale dans des périmètres plus étroits, leur donnant portée de l'espace de noms . Cela permet d'organiser les éléments des programmes dans différentes portées logiques désignées par des noms. Les espaces de noms fournissent l'espace où nous pouvons définir ou déclarer des identifiants, c'est-à-dire des noms de variables, de méthodes, de classes, etc.

  • Un espace de noms est une fonctionnalité ajoutée en C++ et n'est pas présente en C.
  • Un espace de noms est une région déclarative qui fournit une portée aux identifiants (noms de fonctions, variables ou autres types de données définis par l'utilisateur) qu'il contient.
  • Plusieurs blocs d'espace de noms portant le même nom sont autorisés. Toutes les déclarations au sein de ces blocs sont déclarées dans la portée nommée.

Une définition d'espace de noms commence par le mot-clé espace de noms suivi du nom de l'espace de noms comme suit :

namespace namespace_name { int x, y; // code declarations where // x and y are declared in // namespace_name's scope }>
  • Les déclarations d'espace de noms apparaissent uniquement à l'échelle globale.
  • Les déclarations d'espace de noms peuvent être imbriquées dans un autre espace de noms.
  • Les déclarations d'espace de noms n'ont pas de spécificateurs d'accès (Public ou Privé).
  • Pas besoin de donner un point-virgule après l'accolade fermante de la définition de l'espace de noms.
  • Nous pouvons diviser la définition de l'espace de noms sur plusieurs unités.

Définir un espace de noms :

Une définition d'espace de noms commence par le mot-clé namespace suivi du nom de l'espace de noms comme suit :

C++




namespace> namespace_name{> >// code declarations i.e. variable (int a;)> >method (>void> add();)> >classes (>class> student{};)> }> 

>

>

Il est à noter qu’il n’y a pas de point-virgule (;) après l’accolade fermante.
Pour appeler la version compatible avec l'espace de noms d'une fonction ou d'une variable, ajoutez le nom de l'espace de noms comme suit :

nom_espace de noms : :code; // le code peut être une variable, une fonction ou une classe.

C++




// Let us see how namespace scope the entities including variable and functions:> #include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space::func();> >// Calls function from second name space.> >second_space::func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> // Inside second_space> 

>

>

Sortir 

Inside first_space Inside second_space>

La directive using :

Vous pouvez éviter de pré-ajouter des espaces de noms avec la directive using namespace. Cette directive indique au compilateur que le code suivant utilise des noms dans l'espace de noms spécifié. L'espace de noms est donc implicite pour le code suivant :

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> 

>

>

aes contre des
Sortir 

Inside first_space>

Au lieu d'accéder à l'intégralité de l'espace de noms, une autre option (appelée en utilisant déclaration) consiste à accéder à un élément particulier dans un espace de noms. Par exemple, si la seule partie de l'espace de noms std que vous avez l'intention d'utiliser est cout, vous pouvez y faire référence comme suit :
en utilisant std :: cout ;
Le code suivant peut faire référence à cout sans ajouter l'espace de noms, mais les autres éléments de l'espace de noms std devront toujours être explicites comme suit :

C++




#include> using> std::cout;> int> main ()> {> >cout <<>'std::endl is used with std!'> << std::endl;> >return> 0;> }> 

>

>

Sortir 

std::endl is used with std!>

Les noms introduits dans une directive using obéissent aux règles de portée normales, c'est-à-dire qu'ils sont visibles à partir du moment où la directive using apparaît jusqu'à la fin de la portée dans laquelle se trouve la directive. Les entités portant le même nom définies dans une portée externe sont masquées.

C++




// Creating namespaces> #include> using> namespace> std;> namespace> ns1 {> int> value() {>return> 5; }> }>// namespace ns1> namespace> ns2 {> const> double> x = 100;> double> value() {>return> 2 * x; }> }>// namespace ns2> int> main()> {> >// Access value function within ns1> >cout << ns1::value() <<>' '>;> >// Access value function within ns2> >cout << ns2::value() <<>' '>;> >// Access variable x directly> >cout << ns2::x <<>' '>;> >return> 0;> }> 

>

>

Sortir: 

5 200 100>

Classes et espace de noms : Voici un moyen simple de créer des classes dans un espace de noms :

C++




// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns> {> >// A Class in a namespace> >class> geek> >{> >public>:> >void> display()> >{> >cout<<>'ns::geek::display()'>< } }; } int main() { // Creating Object of geek Class ns::geek obj; obj.display(); return 0; }> 

>

>

Sortir 

ns::geek::display()>

Une classe peut également être déclarée dans l'espace de noms et définie en dehors de l'espace de noms en utilisant la syntaxe suivante :

RPC




// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns {> // Only declaring class here> class> geek;> }>// namespace ns> // Defining class outside> class> ns::geek {> public>:> >void> display() { cout <<>'ns::geek::display() '>; }> };> int> main()> {> >// Creating Object of geek Class> >ns::geek obj;> >obj.display();> >return> 0;> }> 

>

>

Sortir 

ns::geek::display()>

Nous pouvons également définir des méthodes en dehors de l'espace de noms . Voici un exemple de code :

C++




// A C++ code to demonstrate that we can define> // methods outside namespace.> #include> using> namespace> std;> // Creating a namespace> namespace> ns {> void> display();> class> geek {> public>:> >void> display();> };> }>// namespace ns> // Defining methods of namespace> void> ns::geek::display()> {> >cout <<>'ns::geek::display() '>;> }> void> ns::display() { cout <<>'ns::display() '>; }> // Driver code> int> main()> {> >ns::geek obj;> >ns::display();> >obj.display();> >return> 0;> }> 

>

>

Sortir: 

ns::display() ns::geek::display():>

Espaces de noms imbriqués :

Les espaces de noms peuvent être imbriqués, c'est-à-dire que vous pouvez définir un espace de noms dans un autre espace de noms comme suit :

C++




namespace> namespace_name1 {> >// code declarations> >namespace> namespace_name2 {> >// code declarations> >}> }> 

>

>

commande arp

Vous pouvez accéder aux membres d'un espace de noms imbriqué à l'aide de l'opérateur de résolution (::) comme suit :

C++




// to access members of namespace_name2> using> namespace> namespace_name1::namespace_name2;> // to access members of namespace:name1> using> namespace> namespace_name1;> 

>

>

Dans les instructions ci-dessus, si vous utilisez namespace_name1, les éléments de namespace_name2 seront disponibles dans la portée comme suit :

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> > >// This calls function from second name space.> >func();> > >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside second_space> 

>

>

Sortir 

Inside second_space>

L'espace de noms offre l'avantage d'éviter les collisions de noms : -

Par exemple, vous écrivez peut-être du code doté d'une fonction appelée xyz() et il existe une autre bibliothèque disponible dans votre code qui possède également la même fonction xyz(). Désormais, le compilateur n'a aucun moyen de savoir à quelle version de la fonction xyz() vous faites référence dans votre code.
Un espace de noms est conçu pour surmonter cette difficulté et est utilisé comme information supplémentaire pour différencier des fonctions, classes, variables, etc. similaires portant le même nom disponibles dans différentes bibliothèques.
Le meilleur exemple de portée d’espace de noms est la bibliothèque standard C++ (std), où toutes les classes, méthodes et modèles sont déclarés. Par conséquent, lors de l’écriture d’un programme C++, nous incluons généralement la directive
en utilisant l'espace de noms std ;

espace de noms en C++ | Ensemble 2 (espace de noms étendu et espace de noms sans nom) Espace de noms en C++ | Ensemble 3 (Accès, création d'en-tête, imbrication et alias) Les espaces de noms peuvent-ils être imbriqués en C++ ? Référence : http://www.cplusplus.com/doc/tutorial/namespaces/