Discussion :

[Disixlis]

Salut tout le monde Aujourd'hui met arrivé un problème que je n'avais jamais eu. J'ai deux namespace où les deux namespace sont "lier" ( le namespace a à besoin du b et inversement ).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
namespace a
{
    enum A{e, l, e, m);
 
   void foo(b::B b);
}
 
namespace b
{
    enum B{t, r, u, c);
 
    void foo(a::A a);
}

Comment faire dans ce cas ?

Merci

[jblecanard]

Hello

Il faut simplement jouer sur l'ordre des déclarations. Il te faut des headers dédiés aux enums puis des headers dédiés aux fonctions, séparés.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace a {
enum A{e, l, m};
}
 
namespace b {
enum B{t, r, u, c};
}
 
namespace a {
void foo(b::B b);
}
 
namespace b {
void foo(a::A a);
}

[ternel]

Il est aussi possible de faire une "forward declaration" d'une énum.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace b {
  enum B;
}
 
namespace A{
  enum A{...};
  void foo(b::B);
}
 
namespace B{
  enum a{...};
  void foo(a::A);
}

[Disixlis]

Merci pour vos réponses , concernant la "forward declaration" d'une énum, es-que c'est propre de faire comme ça ? Dans tout les cas ça me paraît un peu plus confus de faire comme ça, donc je vais m'en tenir à la première méthode

[ternel]

L'avantage d'une forward declaration (ou déclaration anticipée, en français), c'est que cela peut aider à retirer des includes dans les en-têtes, et donc potentiellement, à réduire les temps de compilations.

[koala01]

Salut,

Bien que les solutions t'aient été données, je crois que, à la base, tu as un sérieux problème de conception!

D'une manière ou d'une autre, un espace de noms peut être assimilé à un "module", et si (je ne fais que changer de terme là) le module A dépend du module B et que module B dépend du module A, la question qu'il est largement temps de se poser est : a-t-on réellement bien fait de séparer le contenu des deux modules

D'ailleurs, c'est bien simple : dés que l'on se trouve face à un problème de dépendance cyclique, (qu'elle survienne entre deux classes, entre deux espaces de noms ou entre deux modules) il serait bon d'envisager de revoir la conception, ne serait-ce que pour pouvoir justifier (si possible, autrement que par un "parce que je n'ai pas le choix" ) cette "cyclicité".

Qu'il y ait un module qui dépende d'un autre, ca peut sembler logique, mais que la dépendance soit cyclique, ca ne présage pas grand chose de bon

@ternel : Attention! j'ai un peu la flegme de vérifier, mais, sauf erreur, il n'y a que les énumérations fortes (enum class, apparues avec C++11) qui supportent la déclaration anticipée.

Maintenant, j'ai peut être loupé quelque chose du fait que les énumérations sont dans des espaces de noms différents, mais j'en doute très fort

Mais bon, le plus simple (pour ce qui concerne les énumérations, en tout cas) est peut-être "tout simplement" de les mettre dans des fichiers d'en-tête qui ne contiendraient qu'elles, histoire que l'inclusion d'un fichier ne provoque pas l'ajout de la définition d'un tas de classes (qui -- elles -- peuvent parfaitement se contenter d'une déclaration anticipée )