Discussion :

[xavierdestev]

Bonjour,,

Quel est l'intéret d'un code tel que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
namespace bamg{
using namespace std;
class R2
{
public: 
double x, y;
}

[BlueMonkey]

Bonjour,

namespace <nom> { ... } : définit un espace de nom.
... ça permet de réduire la portée de ce qui est entre { } à l'espace de nom.

using namespace <nom>; indique que le code qui suit peut utilisé l'espace de nom <nom> sans y faire référence explicitement.

voir FAQ Namespace

[koala01]

Salut,

En gros un espace de noms ( namespace) est une sorte de "boite" qui te permet de séparer les différents éléments afin d'éviter les conflits de noms.

En effet, le nom de l'espace de noms intervient dans le noms complet de la fonction ou de la classe que tu déclares / définis. (on parle de "nom pleinement qualifié )

La directive using namespace te permet juste de "raccourcir" le nom (des fonctions, et des classes) à l'utilisation.

Ainsi, si tu as quelque chose qui correspond à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
namespace Premier{
    namespace Second{
        namespace Troisieme{
             void foo();
        }
        void foo();
   }
   void foo();
}
void foo();

tu au final quatre fonctions nommées "foo" différentes grâce au fait qu'elles sont dans des espaces de noms différents:

• foo() (ligne 10)
• Premier::foo() (ligne 8)
• Premier::Second::foo (ligne 6)
• Premier::Second::Troisieme::foo (ligne 4)

Bien sur, présenté sous cette forme, la directive using namespace n'aura strictement aucun intérêt car, si grâce à cette directive, tu peux éviter d'avoir à écrire à chaque fois Premier::, Premier::Second ou Premier::Second::Troisième (selon l'espace de noms que tu utilises dans ta directive), le fait d'appeler foo() (1) provoquera un conflit de noms avec Premier::foo, Premier::Second::foo ou Premier::Second::Troisieme::foo (en fonction de la directive, toujours)

Par contre, si les différentes fonctions foo étaient déclarées dans différents fichiers d'en-tête, sous la forme de
A.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#ifndef A_H
#define A_H
void foo();
#endif

B.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#ifndef B_H
#define B_H
namespace Premier{
    void foo();
}
#endif

C.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#ifndef C_H
#define C_H
namespace Premier{
    namespace Second{
        void foo();
    }
}
#endif

D.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#ifndef D_H
#define D_H
namespace Premier{
    namespace Second{
        namespace Troisieme{
            void foo();
        }
    }
}
#endif

tu pourrais très bien utiliser la directive using namespace dans un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#include <C.h>
using namespace Premier::Second::Troisieme;
void bar(){
    foo(); // fait appel à Premier::Second::Troisieme::foo();
}

Du moins, tant que A.h n'est pas inclus en même temps qu'un autre fichier d'en-tête et que tu te limites à une seule directive.

Car, tu pourrais arriver à une situation proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#include <B.h>
#inlcude <C.h>
using namespace Premier;
using namespace Premier::Second;
void bar(){
    foo(); // !!! appelle Premier::foo() ou Premier::Second::foo()???
}

ou de sa variante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
#include <B.h>
#inlcude <C.h>
#include <bar.h>
using namespace Premier::Second;
namespace Premier{
    void bar(){
        foo(); // !!! appelle Premier::foo() ou Premier::Second::foo()???
    }
}

Tout cela pour dire qu'il faut être particulièrement attentif lorsque l'on décide d'utiliser la directive using namespace et, surtout, qu'il est préférable de ne jamais l'utiliser dans un fichier d'en-tête (*.h) car, avec le jeu des inclusions en cascade, on n'a aucune idée de l'endroit où elle va agir au final.

Généralement, il est "de bon ton" de considérer que, si une équipe de développement a décidé de placer son projet dans des espaces de noms, c'est pour de bonnes raisons (le fait d'éviter les conflits de noms éventuels).

C'est la raison pour laquelle je suis (à titre personnel) globalement contre l'utilisation de la directive using namespace surtout en ce qui concerne l'espace de noms std car il n'est pas vraiment beaucoup plus long d'écrire quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void bar(){
    std::string str;
    std::cout<</*...<<*/ std::endl;
}

que d'écrire la version utilisant la directive using namespace std;.
Par contre, il faut reconnaitre qu'utiliser de manière systématique du

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Premier::Second::Troisieme::foo()

à chaque fois qu'il faut faire appel à foo n'est vraiment pas efficace en terme de lecture (et il n'y a réellement qu'en terme de lecture que cela pose un problème ).

Plutot que d'utiliser la directive using namespace je conseillerais alors d'utiliser un alias pour l'espace de noms: un nom "personnalisé" qui puisse représenter l'espace de noms qui nous intéresse.

Cela prendrait la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#include <C.h>
 
namespace PDT = Premier::Deuxieme::Troisieme;
 
void bar{
    PDT::foo(); // appelle Premier::Deuxieme::Troisieme::foo()
}

[xavierdestev]

Merci beaucoup pour cette réponse très détaillée et éclairante.