La déclaration en utilisant l'espace de noms std est généralement considérée comme une mauvaise pratique. L'alternative à cette instruction consiste à spécifier l'espace de noms auquel appartient l'identifiant à l'aide de l'opérateur de portée (::) chaque fois que nous déclarons un type.
Bien que la déclaration nous évite de taper norme :: chaque fois que nous souhaitons accéder à une classe ou à un type défini dans l'espace de noms std, il importe l'intégralité du norme espace de noms dans l’espace de noms actuel du programme. Prenons quelques exemples pour comprendre pourquoi cela n'est peut-être pas une si bonne chose
Disons que nous souhaitons utiliser le cout de l'espace de noms std. Alors on écrit
Exemple 1:
RPC
#include> using> namespace> std;> > cout <<>' Something to Display'>;> |
>
>
Maintenant, à un stade ultérieur du développement, nous souhaitons utiliser une autre version de cout qui est implémentée de manière personnalisée dans une bibliothèque appelée foo (par exemple)
RPC
#include> #include> using> namespace> std;> > cout <<>' Something to display'>;> |
>
>
Remarquez maintenant qu'il y a une ambiguïté : vers quelle bibliothèque Cout pointe-t-il ? Le compilateur peut le détecter et ne pas compiler le programme. Dans le pire des cas, le programme peut toujours compiler mais appeler la mauvaise fonction, puisque nous n'avons jamais précisé à quel espace de noms appartenait l'identifiant.
Les espaces de noms ont été introduits en C++ pour résoudre les conflits de noms d'identifiants. Cela garantissait que deux objets pouvaient porter le même nom tout en étant traités différemment s'ils appartenaient à des espaces de noms différents. Remarquez comment exactement le contraire s’est produit dans cet exemple. Au lieu de résoudre un conflit de noms, nous créons en fait un conflit de noms.
Lorsque nous importons un espace de noms, nous extrayons essentiellement toutes les définitions de types dans la portée actuelle. L'espace de noms std est énorme. Il contient des centaines d'identifiants prédéfinis, il est donc possible qu'un développeur néglige le fait qu'il existe une autre définition de son objet prévu dans la bibliothèque std. Ignorant cela, ils peuvent procéder à la spécification de leur propre implémentation et s'attendre à ce qu'elle soit utilisée dans des parties ultérieures du programme. Il existerait donc deux définitions pour le même type dans l'espace de noms actuel. Ceci n'est pas autorisé en C++, et même si le programme compile, il n'y a aucun moyen de savoir quelle définition est utilisée et où.
La solution au problème consiste à spécifier explicitement à quel espace de noms appartient notre identifiant à l'aide de l'opérateur de portée (::). Ainsi, une solution possible à l'exemple ci-dessus peut être
chaîne comparer à java
RPC
#include> #include> > // Use cout of std library> std::cout <<>'Something to display'>;> > // Use cout of foo library> foo::cout <>'Something to display'>;> |
>
>
Mais je dois taper norme :: chaque fois que nous définissons un type, c'est fastidieux. Cela rend également notre code plus poilu avec de nombreuses définitions de types et rend la lecture du code difficile. Considérons par exemple le code permettant d'obtenir l'heure actuelle dans le programme
Exemple 2 :
RPC
#include> #include> > auto> start = std::chrono::high_performance_clock::now()> > // Do Something> > auto> stop> >= std::chrono::high_peformance_clock::now();> auto> duration> >= std::duration_cast(stop - start);> |
>
>
Le code source qui regorge de définitions de types compliquées et longues n’est pas très facile à lire. C’est quelque chose que les développeurs cherchent à éviter puisque la maintenabilité du code est pour eux la plus importante.
Il existe plusieurs façons de résoudre ce dilemme, c'est-à-dire spécifier un espace de noms exact sans encombrer le code avec des mots-clés std.
Pensez à utiliser des typedefs
Les typedefs nous évitent d'écrire de longues définitions de types. Dans notre exemple 1, nous pourrions résoudre le problème en utilisant deux typedefs, un pour la bibliothèque std et un autre pour foo.
RPC
table de hachage Java
#include> #include> > typedef> std::cout cout_std;> typedef> foo::cout cout_foo;> > cout_std <<>'Something to write'>;> cout_foo <<>'Something to write'>;> |
>
>
Au lieu d'importer des espaces de noms entiers, importez un espace de noms tronqué
Dans l'exemple 2, nous aurions pu importer uniquement l'espace de noms chrono sous std.
RPC
#include> #include> > // Import only the chrono namespace under std> using> std::chrono;> > auto> start = high_performance_clock::now();> > // Do Something> auto> stop = high_performance_clock::now();> auto> duration duration_cast(stop - start);> |
>
>
Nous pouvons également utiliser l'instruction pour importer un identifiant unique. Pour importer uniquement std :: cout, nous pourrions utiliser
using std::cout;>
Si vous importez toujours des espaces de noms entiers, essayez de le faire dans des fonctions ou dans une portée limitée et non dans une portée globale.
Utilisez l'instruction std using namespace dans les définitions de fonction ou de classe, les définitions de structure. Ce faisant, les définitions d'espace de noms sont importées dans une portée locale, et nous savons au moins d'où d'éventuelles erreurs peuvent provenir si elles surviennent.
RPC
#include> > // Avoid this> using> namespace> std;> > void> foo()> {> >// Inside function> >// Use the import statement inside limited scope> >using> namespace> std;> > >// Proceed with function> }> |
>
>
Conclusion.
Nous avons discuté de méthodes alternatives pour accéder à un identifiant à partir d'un espace de noms. Dans tous les cas, évitez d’importer des espaces de noms entiers dans le code source.
Même si l’apprentissage et le développement de bonnes pratiques de codage peuvent prendre un certain temps, elles s’avèrent généralement payantes à long terme. Écrire un code propre, sans ambiguïté et robuste, sans erreur, devrait être l'intention de tout développeur de programmation.
qu'est-ce que la ruche