D'autres m'ont dit que l'écriture using namespace std;dans le code est incorrecte et que je devrais utiliser std::coutet std::cindirectement à la place.

Pourquoi est-ce using namespace std;considéré comme une mauvaise pratique? Est-ce inefficace ou risque-t-il de déclarer des variables ambiguës (variables qui partagent le même nom qu'une fonction dans l' stdespace de noms)? Cela a-t-il un impact sur les performances?

Ce n'est pas du tout lié aux performances. Mais considérez ceci: vous utilisez deux bibliothèques appelées Foo et Bar:

using namespace foo;
using namespace bar;

Tout fonctionne bien, et vous pouvez appeler Blah()de Foo et Quux()de Bar sans problème. Mais un jour, vous passez à une nouvelle version de Foo 2.0, qui propose désormais une fonction appelée Quux(). Vous avez maintenant un conflit: Foo 2.0 et Bar importent Quux()dans votre espace de noms global. Cela va prendre un certain effort à résoudre, surtout si les paramètres de fonction correspondent.

Si vous aviez utilisé foo::Blah()et bar::Quux(), alors l'introduction de foo::Quux()aurait été un non-événement.

Je suis d'accord avec tout ce que Greg a écrit , mais j'aimerais ajouter: cela peut même empirer ce que Greg a dit!

La bibliothèque Foo 2.0 pourrait introduire une fonction, Quux()qui correspond sans aucun doute mieux à certains de vos appels Quux()que le bar::Quux()code appelé depuis des années. Ensuite, votre code compile toujours , mais il appelle silencieusement la mauvaise fonction et fait quoi que ce soit. C'est aussi mauvais que les choses peuvent arriver.

Gardez à l' esprit que l' stdespace de noms a des tonnes d'identificateurs, dont beaucoup sont très plus communs (penser list, sort, string, iterator, etc.) qui sont très susceptibles d'apparaître dans tout autre code, aussi.

Si vous considérez cela comme improbable: Il y avait une question posée ici sur Stack Overflow où à peu près exactement cela s'est produit (mauvaise fonction appelée en raison du std::préfixe omis ) environ six mois après avoir donné cette réponse. Voici un autre exemple plus récent d'une telle question. C'est donc un vrai problème.

Voici un autre point de données: il y a de nombreuses années, je trouvais également ennuyeux de devoir tout préfixer de la bibliothèque standard avec std::. Ensuite, j'ai travaillé dans un projet où il a été décidé au début que les usingdirectives et les déclarations étaient interdites, sauf pour les étendues de fonction. Devine quoi? La plupart d'entre nous ont mis très peu de semaines à s'habituer à écrire le préfixe, et après quelques semaines de plus, la plupart d'entre nous ont même convenu que cela rendait le code plus lisible . Il y a une raison à cela: que vous aimiez une prose plus ou moins longue est subjectif, mais les préfixes ajoutent objectivement de la clarté au code. Non seulement le compilateur, mais vous aussi, trouvez plus facilement à quel identifiant il est fait référence.

En une décennie, ce projet s'est développé pour compter plusieurs millions de lignes de code. Étant donné que ces discussions reviennent encore et encore, j'ai été curieux de savoir à quelle fréquence la fonction (autorisée) usingétait réellement utilisée dans le projet. J'ai recherché les sources et trouvé seulement une ou deux douzaines d'endroits où il était utilisé. Pour moi, cela indique qu'une fois essayé, les développeurs ne trouvent pas std::assez pénible d'utiliser des directives, même une fois tous les 100 kLoC, même là où il a été autorisé à les utiliser.

Conclusion: préfixer explicitement tout ne fait pas de mal, demande très peu de temps pour s'y habituer et présente des avantages objectifs. En particulier, cela rend le code plus facile à interpréter par le compilateur et par les lecteurs humains - et cela devrait probablement être l'objectif principal lors de l'écriture de code.

Le problème avec la mise using namespacedans les fichiers d'en-tête de vos classes est qu'il oblige quiconque veut utiliser vos classes (en incluant vos fichiers d'en-tête) à «utiliser» (c'est-à-dire tout voir) dans ces autres espaces de noms.

Cependant, vous pouvez vous sentir libre de mettre une instruction using dans vos fichiers (privés) * .cpp.

Attention, certaines personnes ne sont pas d'accord avec mon énoncé "n'hésitez pas" comme ceci - parce que même si une usingdéclaration dans un fichier cpp est meilleure que dans un en-tête (car elle n'affecte pas les personnes qui incluent votre fichier d'en-tête), ils pensent que ce n'est toujours pas le cas bon (car en fonction du code, cela pourrait rendre l'implémentation de la classe plus difficile à maintenir). Cette entrée C ++ Super-FAQ dit,

La directive using existe pour le code C ++ hérité et pour faciliter la transition vers les espaces de noms, mais vous ne devriez probablement pas l'utiliser régulièrement, du moins pas dans votre nouveau code C ++.

La FAQ propose deux alternatives:

• Une déclaration d'utilisation:

  using std::cout; // a using-declaration lets you use cout without qualification
  cout << "Values:";

• Il suffit de taper std ::

  std::cout << "Values:";

J'ai récemment rencontré une plainte concernant Visual Studio 2010 . Il s'est avéré que presque tous les fichiers source avaient ces deux lignes:

using namespace std;
using namespace boost;

De nombreuses fonctionnalités Boost sont intégrées dans la norme C ++ 0x, et Visual Studio 2010 possède de nombreuses fonctionnalités C ++ 0x, donc soudainement ces programmes ne se compilaient pas.

Par conséquent, en évitant using namespace X; est une forme de pérennisation, un moyen de s'assurer qu'une modification des bibliothèques et / ou des fichiers d'en-tête utilisés ne va pas casser un programme.

Version courte: n'utilisez pas de usingdéclarations ou directives globales dans les fichiers d'en-tête. N'hésitez pas à les utiliser dans les fichiers d'implémentation. Voici ce que Herb Sutter et Andrei Alexandrescu ont à dire à propos de ce problème dans les normes de codage C ++ (les caractères gras sont les miens):

Sommaire

Les utilisations des espaces de noms sont pour votre commodité, pas pour que vous les infligiez aux autres: N'écrivez jamais une déclaration using ou une directive using avant une directive #include.

Corollaire: dans les fichiers d'en-tête, n'écrivez pas au niveau de l'espace de noms à l'aide de directives ou de déclarations; à la place, qualifiez explicitement tous les noms. (La deuxième règle découle de la première, car les en-têtes ne peuvent jamais savoir quels autres en-têtes #includes pourraient apparaître après eux.)

Discussion

En bref: vous pouvez et devez utiliser l'espace de noms à l'aide de déclarations et de directives généreusement dans vos fichiers d'implémentation après les directives #include et vous en sentir bien. Malgré les affirmations répétées du contraire, l'espace de noms utilisant des déclarations et des directives n'est pas mauvais et ne va pas à l'encontre de l'objectif des espaces de noms. C'est plutôt ce qui rend les espaces de noms utilisables .

Il ne faut pas utiliser la usingdirective à l'échelle mondiale, en particulier dans les en-têtes. Cependant, il existe des situations où cela est approprié même dans un fichier d'en-tête:

template <typename FloatType> inline
FloatType compute_something(FloatType x)
{
    using namespace std; // No problem since scope is limited
    return exp(x) * (sin(x) - cos(x * 2) + sin(x * 3) - cos(x * 4));
}

C'est mieux qu'une qualification explicite ( std::sin, std::cos...), car elle est plus courte et a la capacité de travailler avec des types à virgule flottante définis par l'utilisateur (via la recherche dépendante de l'argument (ADL)).

Ne l'utilisez pas globalement

Il est considéré comme «mauvais» uniquement lorsqu'il est utilisé à l'échelle mondiale . Parce que:

• Vous encombrez l'espace de noms dans lequel vous programmez.
• Les lecteurs auront du mal à voir d'où vient un identifiant particulier, lorsque vous en utilisez plusieurs using namespace xyz.
• Ce qui est vrai pour les autres lecteurs de votre code source l'est encore plus pour le lecteur le plus fréquent: vous-même. Revenez dans un an ou deux et jetez un œil ...
• Si vous ne parlez que de using namespace stdvous, vous pourriez ne pas être au courant de toutes les choses que vous saisissez - et lorsque vous en ajoutez une autre #includeou passez à une nouvelle révision C ++, vous risquez d'obtenir des conflits de noms dont vous n'étiez pas au courant.

Vous pouvez l'utiliser localement

Allez-y et utilisez-le localement (presque) librement. Cela, bien sûr, vous empêche de répéterstd:: - et la répétition est également mauvaise.

Un idiome pour l'utiliser localement

En C ++ 03, il y avait un idiome - code passe-partout - pour implémenter une swapfonction pour vos classes. Il a été suggéré que vous utilisiez réellement un local using namespace std- ou au moins using std::swap:

class Thing {
    int    value_;
    Child  child_;
public:
    // ...
    friend void swap(Thing &a, Thing &b);
};
void swap(Thing &a, Thing &b) {
    using namespace std;      // make `std::swap` available
    // swap all members
    swap(a.value_, b.value_); // `std::stwap(int, int)`
    swap(a.child_, b.child_); // `swap(Child&,Child&)` or `std::swap(...)`
}

Cela fait la magie suivante:

• Le compilateur choisira le std::swapfor value_, c'est-à-direvoid std::swap(int, int) .
• Si vous avez une surcharge void swap(Child&, Child&) implémentée, le compilateur la choisira.
• Si tu fais pas cette surcharge, le compilateur les utilisera void std::swap(Child&,Child&)et essaiera de les échanger au mieux.

Avec C ++ 11, il n'y a plus de raison d'utiliser ce modèle. L'implémentation de a std::swapété modifiée pour trouver une surcharge potentielle et la choisir.

Si vous importez les fichiers d' en- tête de droite , vous avez soudainement des noms comme hex, left, plusou countdans votre portée globale. Cela peut être surprenant si vous ne savez pas qui std::contient ces noms. Si vous essayez également d'utiliser ces noms localement, cela peut entraîner une certaine confusion.

Si tous les éléments standard se trouvent dans son propre espace de noms, vous n'avez pas à vous soucier des collisions de noms avec votre code ou d'autres bibliothèques.

Une autre raison est la surprise.

Si je vois cout << blah, au lieu de std::cout << blahje pense: qu'est-ce que c'est cout? Est-ce normal cout? Est-ce quelque chose de spécial?

Les programmeurs expérimentés utilisent tout ce qui résout leurs problèmes et évitent tout ce qui crée de nouveaux problèmes, et ils évitent les directives d'utilisation au niveau du fichier d'en-tête pour cette raison exacte.

Les programmeurs expérimentés tentent également d'éviter la qualification complète des noms dans leurs fichiers source. Une raison mineure à cela est qu'il n'est pas élégant d'écrire plus de code lorsque moins de code est suffisant, sauf s'il existe de bonnes raisons . Une raison principale à cela est la désactivation de la recherche dépendante des arguments (ADL).

Quelles sont ces bonnes raisons ? Parfois, les programmeurs veulent explicitement désactiver ADL, d'autres fois ils veulent lever l'ambiguïté.

Donc, ce qui suit est OK:

1. Directives d'utilisation et déclarations d'utilisation au niveau des fonctions dans les implémentations des fonctions
2. Déclarations d'utilisation au niveau du fichier source dans les fichiers source
3. (Parfois) directives d'utilisation au niveau du fichier source

Je suis d'accord qu'il ne devrait pas être utilisé globalement, mais ce n'est pas si mal d'utiliser localement, comme dans a namespace. Voici un exemple de "The C ++ Programming Language" :

namespace My_lib {

    using namespace His_lib; // Everything from His_lib
    using namespace Her_lib; // Everything from Her_lib

    using His_lib::String; // Resolve potential clash in favor of His_lib
    using Her_lib::Vector; // Resolve potential clash in favor of Her_lib

}

Dans cet exemple, nous avons résolu les conflits de noms potentiels et les ambiguïtés résultant de leur composition.

Les noms qui y sont explicitement déclarés (y compris les noms déclarés par des déclarations using comme His_lib::String) ont priorité sur les noms rendus accessibles dans une autre portée par une directive using ( using namespace Her_lib).

Je considère également que c'est une mauvaise pratique. Pourquoi? Un jour, j'ai pensé que la fonction d'un espace de noms était de diviser des choses, donc je ne devrais pas le gâcher en jetant tout dans un seul sac global.

Cependant, si j'utilise souvent 'cout' et 'cin', j'écris: using std::cout; using std::cin;dans le fichier .cpp (jamais dans le fichier d'en-tête car il se propage avec #include). Je pense que personne sain d'esprit ne nommera jamais un flux coutou cin. ;)

C'est agréable de voir le code et de savoir ce qu'il fait. Si je vois, std::coutje sais que c'est lecout flux de la stdbibliothèque. Si je vois, coutje ne sais pas. Ce pourrait être le coutflux de la stdbibliothèque. Ou il pourrait y avoir int cout = 0;dix lignes plus haut dans la même fonction. Ou une staticvariable nomméecout dans ce fichier. Ça pourrait être n'importe quoi.

Maintenant, prenez une base de code d'un million de lignes, ce qui n'est pas particulièrement gros, et vous recherchez un bogue, ce qui signifie que vous savez qu'il y a une ligne dans ce million de lignes qui ne fait pas ce qu'elle est censée faire. cout << 1;pourrait lire un static intnom cout, le déplacer d'un bit vers la gauche et jeter le résultat. Vous cherchez un bug, je devrais vérifier cela. Pouvez-vous voir comment je préfère vraiment voirstd::cout ?

C'est une de ces choses qui semble vraiment une bonne idée si vous êtes un enseignant et que vous n'avez jamais eu à écrire et à maintenir un code pour vivre. J'adore voir du code où (1) je sais ce qu'il fait; et, (2) je suis convaincu que la personne qui l'écrit savait ce qu'il fait.

Il s'agit de gérer la complexité. L'utilisation de l'espace de noms entraînera des choses que vous ne voulez pas, et donc rendra peut-être plus difficile le débogage (je dis peut-être). Utiliser std :: partout est plus difficile à lire (plus de texte et tout ça).

Chevaux pour les cours - gérez votre complexité comme vous le pouvez et sentez-vous le mieux possible.

Considérer

// myHeader.h
#include <sstream>
using namespace std;


// someoneElses.cpp/h
#include "myHeader.h"

class stringstream {  // Uh oh
};

Notez que ceci est un exemple simple. Si vous avez des fichiers avec 20 inclusions et autres importations, vous aurez une tonne de dépendances à traverser pour comprendre le problème. Le pire, c'est que vous pouvez obtenir des erreurs non liées dans d'autres modules en fonction des définitions en conflit.

Ce n'est pas horrible, mais vous vous éviterez des maux de tête en ne l'utilisant pas dans les fichiers d'en-tête ou l'espace de noms global. C'est probablement bien de le faire dans des portées très limitées, mais je n'ai jamais eu de problème à taper les cinq caractères supplémentaires pour clarifier d'où viennent mes fonctions.

1. Vous devez être capable de lire du code écrit par des personnes qui ont des opinions de style et de meilleures pratiques différentes de vous.

2. Si vous utilisez uniquement cout, personne ne se trompe. Mais lorsque vous avez beaucoup d'espaces de noms qui volent et que vous voyez cette classe et que vous n'êtes pas exactement sûr de ce qu'elle fait, avoir l'espace de noms explicite agit en quelque sorte comme un commentaire. Vous pouvez voir à première vue, "oh, c'est une opération de système de fichiers" ou "qui fait des trucs de réseau".

L'utilisation de nombreux espaces de noms en même temps est évidemment une recette pour un désastre, mais en utilisant l'espace de noms JUST stdet uniquement l'espace de nomsstd n'est pas si grave à mon avis car la redéfinition ne peut se produire que par votre propre code ...

Il suffit donc de les considérer comme des fonctions réservées comme "int" ou "classe" et c'est tout.

Les gens devraient cesser d'être si anaux à ce sujet. Votre professeur avait raison depuis le début. Utilisez simplement UN espace de noms; c'est tout l'intérêt d'utiliser les espaces de noms en premier lieu. Vous n'êtes pas censé en utiliser plusieurs en même temps. A moins que ce ne soit le vôtre. Encore une fois, la redéfinition ne se produira pas.

Je suis d'accord avec les autres ici, mais je voudrais répondre aux préoccupations concernant la lisibilité - vous pouvez éviter tout cela en utilisant simplement des typedefs en haut de votre fichier, fonction ou déclaration de classe.

Je l'utilise généralement dans ma déclaration de classe car les méthodes d'une classe ont tendance à traiter des types de données similaires (les membres) et un typedef est une opportunité pour attribuer un nom significatif dans le contexte de la classe. Cela facilite en fait la lisibilité dans les définitions des méthodes de classe.

// Header
class File
{
   typedef std::vector<std::string> Lines;
   Lines ReadLines();
}

et dans la mise en œuvre:

// .cpp
Lines File::ReadLines()
{
    Lines lines;
    // Get them...
    return lines;
}

par opposition à:

// .cpp
vector<string> File::ReadLines()
{
    vector<string> lines;
    // Get them...
    return lines;
}

ou:

// .cpp
std::vector<std::string> File::ReadLines()
{
    std::vector<std::string> lines;
    // Get them...
    return lines;
}

Un exemple concret pour clarifier la préoccupation. Imaginez que vous ayez une situation où vous avez deux bibliothèques fooet barchacune avec son propre espace de noms:

namespace foo {
    void a(float) { /* Does something */ }
}

namespace bar {
    ...
}

Supposons maintenant que vous utilisez fooet barensemble dans votre propre programme comme suit:

using namespace foo;
using namespace bar;

void main() {
    a(42);
}

À ce stade, tout va bien. Lorsque vous exécutez votre programme, il «fait quelque chose». Mais plus tard, vous mettez à jour baret disons qu'il a changé pour ressembler à:

namespace bar {
    void a(float) { /* Does something completely different */ }
}

À ce stade, vous obtiendrez une erreur de compilation:

using namespace foo;
using namespace bar;

void main() {
    a(42);  // error: call to 'a' is ambiguous, should be foo::a(42)
}

Vous aurez donc besoin de faire un peu de maintenance pour clarifier que «a» signifiait foo::a. Ce n'est pas souhaitable, mais heureusement, c'est assez facile (il suffit d'ajouter foo::devant tous les appels àa que le compilateur marque comme ambigu).

Mais imaginez un scénario alternatif où la barre a changé à la place pour ressembler à ceci:

namespace bar {
    void a(int) { /* Does something completely different */ }
}

À ce stade, votre appel à a(42)se lie soudainement à la bar::aplace de foo::aet au lieu de faire «quelque chose», il fait «quelque chose de complètement différent». Aucun avertissement du compilateur ou quoi que ce soit. Votre programme commence juste silencieusement à faire quelque chose de complètement différent qu'auparavant.

Lorsque vous utilisez un espace de noms, vous risquez un scénario comme celui-ci, c'est pourquoi les gens ne sont pas à l'aise avec les espaces de noms. Plus il y a de choses dans un espace de noms, plus le risque de conflit est grand, donc les gens pourraient être encore plus mal à l'aise d'utiliser l'espace de nomsstd (en raison du nombre de choses dans cet espace de noms) que les autres espaces de noms.

En fin de compte, il s'agit d'un compromis entre l'écritabilité et la fiabilité / maintenabilité. La lisibilité peut également prendre en compte, mais je pouvais voir des arguments pour que cela aille dans les deux sens. Normalement, je dirais que la fiabilité et la maintenabilité sont plus importantes, mais dans ce cas, vous paierez constamment le coût d'écriture pour un impact relativement rare sur la fiabilité / maintenabilité. Le «meilleur» compromis déterminera votre projet et vos priorités.

Un espace de noms est une étendue nommée. Les espaces de noms sont utilisés pour regrouper les déclarations liées et pour séparer les éléments séparés. Par exemple, deux bibliothèques développées séparément peuvent utiliser le même nom pour faire référence à des éléments différents, mais un utilisateur peut toujours utiliser les deux:

namespace Mylib{
    template<class T> class Stack{ /* ... */ };
    // ...
}

namespace Yourlib{
    class Stack{ /* ... */ };
    // ...
}

void f(int max) {
    Mylib::Stack<int> s1(max); // Use my stack
    Yourlib::Stack    s2(max); // Use your stack
    // ...
}

La répétition d'un nom d'espace de noms peut être une distraction pour les lecteurs et les écrivains. Par conséquent, il est possible d'indiquer que les noms d'un espace de noms particulier sont disponibles sans qualification explicite. Par exemple:

void f(int max) {
    using namespace Mylib; // Make names from Mylib accessible
    Stack<int> s1(max); // Use my stack
    Yourlib::Stack s2(max); // Use your stack
    // ...
}

Les espaces de noms fournissent un outil puissant pour la gestion de différentes bibliothèques et de différentes versions de code. En particulier, ils offrent au programmeur des alternatives sur la façon explicite de faire référence à un nom non local.

Source: Un aperçu du langage de programmation C ++ par Bjarne Stroustrup

Un exemple où using namespace stdgénère une erreur de compilation en raison de l'ambiguïté de count, qui est également une fonction de la bibliothèque d'algorithmes.

#include <iostream>

using namespace std;

int count = 1;
int main() {
    cout << count << endl;
}

Cela n'aggrave pas les performances de votre logiciel ou de votre projet. L'inclusion de l'espace de noms au début de votre code source n'est pas mauvaise. L'inclusion de l' using namespace stdinstruction varie en fonction de vos besoins et de la façon dont vous développez le logiciel ou le projet.

Le namespace stdcontient les fonctions et variables standard C ++. Cet espace de noms est utile lorsque vous utilisez souvent les fonctions standard C ++.

Comme mentionné dans cette page :

L'instruction utilisant l'espace de noms std est généralement considérée comme une mauvaise pratique. L'alternative à cette instruction est de spécifier l'espace de noms auquel l'identifiant appartient en utilisant l'opérateur scope (: :) chaque fois que nous déclarons un type.

Et voyez cet avis :

Il n'y a aucun problème à utiliser "using namespace std" dans votre fichier source lorsque vous faites un usage intensif de l'espace de noms et que vous savez avec certitude que rien ne va entrer en collision.

Certaines personnes avaient dit que c'était une mauvaise pratique d'inclure le using namespace stddans vos fichiers source parce que vous appelez à partir de cet espace de noms toutes les fonctions et variables. Lorsque vous souhaitez définir une nouvelle fonction avec le même nom qu'une autre fonction contenue dans le, namespace stdvous surchargez la fonction et cela pourrait produire des problèmes dus à la compilation ou à l'exécution. Il ne se compilera pas ou ne s'exécutera pas comme prévu.

Comme mentionné dans cette page :

Bien que l'instruction nous évite de taper std :: chaque fois que nous souhaitons accéder à une classe ou à un type défini dans l'espace de noms std, elle importe l'intégralité de l'espace de noms std dans l'espace de noms actuel du programme. Prenons quelques exemples pour comprendre pourquoi ce n'est peut-être pas une si bonne chose

...

Maintenant, à un stade ultérieur du développement, nous souhaitons utiliser une autre version de cout qui est implémentée sur mesure dans une bibliothèque appelée "foo" (par exemple)

...

Remarquez comment il y a une ambiguïté, vers quelle bibliothèque pointe-t-on? Le compilateur peut détecter cela et ne pas compiler le programme. Dans le pire des cas, le programme peut toujours compiler mais appeler la mauvaise fonction, car nous n'avons jamais spécifié à quel espace de noms l'identifiant appartenait.

Je ne pense pas que ce soit nécessairement une mauvaise pratique dans toutes les conditions, mais vous devez être prudent lorsque vous l'utilisez. Si vous écrivez une bibliothèque, vous devriez probablement utiliser les opérateurs de résolution de portée avec l'espace de noms pour empêcher votre bibliothèque de buter avec d'autres bibliothèques. Pour le code au niveau de l'application, je ne vois rien de mal à cela.

"Pourquoi" utiliser l'espace de noms std; " considéré comme une mauvaise pratique en C ++? "

Je l'inverse: pourquoi la saisie de cinq caractères supplémentaires est-elle considérée comme lourde par certains?

Considérez par exemple l'écriture d'un logiciel numérique. Pourquoi envisagerais-je même de polluer mon espace de noms global en coupant "std :: vector" en "vector" alors que "vector" est l'un des concepts les plus importants du domaine problématique?

Je suis d'accord avec les autres - cela demande des affrontements de noms, des ambiguïtés et le fait est que c'est moins explicite. Bien que je puisse voir l'utilisation de using, ma préférence personnelle est de la limiter. Je considérerais également fortement ce que certains ont souligné:

Si vous voulez trouver un nom de fonction qui pourrait être un nom assez courant, mais que vous voulez seulement le trouver dans l' stdespace de noms (ou l'inverse - vous voulez changer tous les appels qui ne sont pas dans l'espace de noms std, l'espace de noms X, ...), alors comment proposez-vous de faire cela?

Vous pourriez écrire un programme pour le faire, mais ne serait-il pas préférable de passer du temps à travailler sur votre projet lui-même plutôt que d'écrire un programme pour maintenir votre projet?

Personnellement, cela ne me dérange pas vraiment le std::préfixe. J'aime le look plus que de ne pas l'avoir. Je ne sais pas si c'est parce que c'est explicite et me dit "ce n'est pas mon code ... j'utilise la bibliothèque standard" ou si c'est autre chose, mais je pense que c'est plus joli. Cela peut être étrange étant donné que je ne suis entré que récemment dans C ++ (utilisé et continue de faire du C et d'autres langages beaucoup plus longtemps et C est mon langage préféré de tous les temps, juste au-dessus de l'assemblage).

Il y a une autre chose bien qu'elle soit quelque peu liée à ce qui précède et à ce que d'autres soulignent. Bien que cela puisse être une mauvaise pratique, je réserve parfois std::namela version et le nom de la bibliothèque standard pour une implémentation spécifique au programme. Oui, en effet, cela pourrait vous mordre et vous mordre fort, mais tout se résume à ce que j'ai commencé ce projet à partir de zéro, et je suis le seul programmeur pour cela. Exemple: je surcharge std::stringet l'appelle string. J'ai des ajouts utiles. Je l'ai fait en partie à cause de ma tendance C et Unix (+ Linux) vers les noms en minuscules.

En plus de cela, vous pouvez avoir des alias d'espace de noms. Voici un exemple où il est utile qui pourrait ne pas avoir été mentionné. J'utilise la norme C ++ 11 et spécifiquement avec libstdc ++. Eh bien, il n'a pas de std::regexsupport complet . Bien sûr, il compile, mais il lève une exception dans le sens où il s'agit d'une erreur de la part du programmeur. Mais c'est le manque de mise en œuvre.

Voici donc comment je l'ai résolu. Installez le regex de Boost et liez-le. Ensuite, je fais ce qui suit pour que lorsque libstdc ++ l'a complètement implémenté, je n'ai besoin que de supprimer ce bloc et le code reste le même:

namespace std
{
    using boost::regex;
    using boost::regex_error;
    using boost::regex_replace;
    using boost::regex_search;
    using boost::regex_match;
    using boost::smatch;
    namespace regex_constants = boost::regex_constants;
}

Je ne dirai pas si c'est une mauvaise idée ou non. Je dirai cependant qu'il le garde propre pour mon projet et en même temps le rend spécifique: Vrai, je dois utiliser Boost, mais je l'utilise comme le libstdc ++ l'aura finalement. Oui, démarrer votre propre projet et commencer par une norme (...) au tout début va très loin dans la maintenance, le développement et tout ce qui est impliqué dans le projet!

Juste pour clarifier quelque chose: je ne pense pas que ce soit une bonne idée d'utiliser délibérément et plus spécifiquement le nom d'une classe / quoi que ce soit dans la STL . La chaîne est l'exception (ignorez le premier, ci-dessus ou deuxième ici, jeu de mots si vous devez) pour moi car je n'aimais pas l'idée de «chaîne».

En l'état, je suis toujours très partisan de C et partisan de C ++. Des détails épargnés, une grande partie de ce sur quoi je travaille correspond plus à C (mais c'était un bon exercice et un bon moyen de me faire a. Apprendre une autre langue et b. Essayer de ne pas être moins biaisé contre les objets / classes / etc qui est peut-être mieux énoncé moins fermés, moins arrogants et plus acceptants.). Mais ce qui est utile, c'est ce que certains ont déjà suggéré: j'utilise effectivement list (c'est assez générique, n'est-ce pas?), Et trie (même chose) pour en nommer deux qui provoqueraient un conflit de nom si je le faisais using namespace std;, et ainsi à cette fin, je préfère être spécifique, en contrôle et sachant que si je veux que ce soit l'utilisation standard, je devrai le préciser. En termes simples: aucune supposition autorisée.

Et quant à faire partie des regex de Boost std. Je le fais pour une intégration future et - encore une fois, j'admets pleinement que c'est un parti pris - je ne pense pas que ce soit aussi moche que boost::regex:: .... En effet, c'est autre chose pour moi. Il y a beaucoup de choses en C ++ que je dois encore accepter pleinement dans les looks et les méthodes (un autre exemple: les modèles variadiques contre les arguments var [bien que j'admette que les modèles variadiques soient très très utiles!]). Même ceux que j'accepte, c'était difficile, et j'ai toujours des problèmes avec eux.

D'après mon expérience, si vous avez plusieurs bibliothèques qui utilisent disons cout, mais à des fins différentes, vous pouvez utiliser le mauvais cout.

Par exemple, si je tape using namespace std;et using namespace otherlib;et que je tape juste cout(qui se trouve être dans les deux), plutôt que std::cout(ou 'otherlib::cout'), vous pouvez utiliser la mauvaise et obtenir des erreurs. C'est beaucoup plus efficace et efficient à utiliser std::cout.

Avec les identifiants importés non qualifiés, vous avez besoin d'outils de recherche externes comme grep pour savoir où les identifiants sont déclarés. Cela rend le raisonnement sur la correction du programme plus difficile.

Cela dépend de l'endroit où il se trouve. S'il s'agit d'un en-tête commun, vous diminuez la valeur de l'espace de noms en le fusionnant dans l'espace de noms global. Gardez à l'esprit que cela pourrait être une bonne façon de créer des modules globaux.

Il s'agit d'une mauvaise pratique, souvent appelée pollution globale des espaces de noms. Des problèmes peuvent survenir lorsque plusieurs espaces de noms ont le même nom de fonction avec signature, alors il sera ambigu pour le compilateur de décider lequel appeler et tout cela peut être évité lorsque vous spécifiez l'espace de noms avec votre appel de fonction comme std::cout. J'espère que cela t'aides. :)

Pour répondre à votre question, je le vois de cette façon pratiquement: beaucoup de programmeurs (pas tous) invoquent l'espace de noms std. Par conséquent, on devrait avoir l'habitude de NE PAS utiliser des choses qui empiètent ou utilisent les mêmes noms que ce qui se trouve dans l'espace de noms std. C'est beaucoup accordé, mais pas tellement par rapport au nombre de mots cohérents et de pseudonymes possibles qui peuvent être proposés à proprement parler.

Je veux dire vraiment ... dire "ne comptez pas sur le fait d'être présent", c'est simplement vous mettre en place pour compter sur le fait qu'il ne soit PAS présent. Vous allez constamment rencontrer des problèmes pour emprunter des extraits de code et les réparer constamment. Gardez simplement vos éléments définis par l'utilisateur et empruntés dans une portée limitée comme ils devraient l'être et soyez TRÈS épargnant avec les globaux (honnêtement, les globaux devraient presque toujours être un dernier recours aux fins de "compiler maintenant, sain d'esprit plus tard"). Vraiment, je pense que c'est un mauvais conseil de votre professeur car utiliser std fonctionnera à la fois pour "cout" et "std :: cout" mais NE PAS utiliser std ne fonctionnera que pour "std :: cout". Vous n'aurez pas toujours la chance d'écrire tout votre code.

REMARQUE: ne vous concentrez pas trop sur les problèmes d'efficacité avant d'avoir réellement appris un peu sur le fonctionnement des compilateurs. Avec un peu d'expérience en codage, vous n'avez pas besoin d'en apprendre beaucoup à leur sujet avant de réaliser à quel point ils sont capables de généraliser un bon code en quelque chose de simple. Tout aussi simple que si vous aviez écrit le tout en C. Un bon code n'est aussi complexe que nécessaire.