Discussion :

[transgohan]

Bonjour à toutes et à tous,

je fais depuis ce matin quelques recherches et tests avec les namespaces C++ auquels je n'avais jamais touché jusqu'à maintenant.
Ma problématique est simple, j'aurai à terme des class du même nom d'où l'utilisation de namespace.
Chacun de ces namespaces sera appelé sans intéraction avec les autres, un peu comme deux applications totalement différentes mais compilées en une.

J'ai donc fait quelques tests pour un point d'entrée conditionnel.
Voici ce qu'il est possible de faire dans un premier temps :

Code :

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

1
2
3
4
5
6
7
8
9
void exec(string name){
  if( name == "foo" ){
    using namespace foo;
    someClass::exec();
  }else{
    using namespace bar;
    someClass::exec();
  }
}

Le code étant simplifié pour l'exemple, mais j'aurai à terme des milliers de lignes à la place de l'appel à someClass::exec(). Or à cause de cette déclaration de namespace il va me falloir dupliquer le même code !
Je précise que je ne veux pas préfixer mes appels par le namespace, c'est pas le but de tout réécrire justement.

J'ai réfléchi à tout ce qui me passait par la tête, constante (mais évalué à la compilation donc pas bon), variable (passe pas dans un using namespace), sans trouver mieux que ce que j'ai posté.

Auriez-vous une méthode autre que celle là qui pourrait me statisfaire ? Ou une autre façon de traiter ce problème ?

Cordialement,
xTG.

[ternel]

Tu peux rendre ta fonction template, en prenant en parametre soit foo::someClass, soit bar::someClass

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace{
template <class someClass>
void exec_inner(string name){
    someClass::exec();
}
};
 
void exec(string name){
  if( name == "foo" ){
    exec_inner<foo::someClass>(name);
  }else{
    exec_inner<bar::someClass>(name);
  }
}

Sinon, tu peux te tourner du coter des librairies dynamiques

[3DArchi]

Salut,

Auriez-vous une méthode autre que celle là qui pourrait me statisfaire ? Ou une autre façon de traiter ce problème ?

2 dlls (ou l'équivalent selon ton OS).

[transgohan]

Merci pour vos réponses.
Finalement cette partie de mes réflexions a été jeté.
Mon chef préfère des fichiers à rallonge à coup de if que des codes qui pourraient ne pas être compris par des futurs stagiaires...
Je m'intérroge tout de même, ce serait quoi pour un stagiaire le plus difficile à comprendre ? Un appel de code asm ou bien l'utilisation d'un namespace ?

Concernant les librairies dynamiques je me suis renseigné, on ajoute tout de même beaucoup de complexité pour pas grand chose. En plus j'ai cru lire dans le lot de documents que j'ai parcouru ce matin que cela apportait aussi un temps de chargement non négligeable à l'application, chose qui ne m'avantage guère étant sur un système temps réel.

[ternel]

Et oui, c'est l'avantage d'un patron, préférer la prise en main par le futur stagiaire, mais exiger les performances...

Un gros if(soft==soft1) loadLibrary("dll1"); else loadLibrary("dll2");, ca ne suffit pas?

[transgohan]

Un gros if(soft==soft1) loadLibrary("dll1"); else loadLibrary("dll2");, ca ne suffit pas?

Et dans le cas où les deux peuvent avoir à être chargées ?
Mon problème n'est pas un chargement exclusif justement, j'ai simplifié à l'extrème le problème présenté. Mais pource que j'en comprends c'est pas les librairies dynamiques qui vont remplacer les namespaces.
Mais bon, l'argument ressorti était aussi qu'il veut pas de fichiers qui se baladent à côté du binaire donc la question est close.

[ternel]

Dans ce cas, have fun et bon courage!

[Jean-Marc.Bourguet]

Il n'y a aucune résolution dynamique de noms en C++. Que ce soit avec les namespaces ou d'une autre manière. Donc il te faut jouer sur la duplication de code.

Une technique en utilisant le préprocesseur qui évite d'avoir à dupliquer les sources:

Code :

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

1
2
3
4
5
6
7
8
 
// fichier A
using namespace Foo;
#include "Impl.inc"
 
// fichier B
using namespace Bar;
#include "Impl.inc"

Le faire avec des templates est vraisemblablement possible, mais ça risque d'être lourd.

Jouer avec les libs dynamiques. Peut-être. À condition qu'il n'y ait pas d'inline ni d'autres dépendances sur l'implémentation (comme par exemple la création d'un objet sur la pile; en fait même l'allocation dynamique d'un objet va poser problème, le résultat va dépendre de la taille, il vaut déléguer ça aussi à la lib dynamique).

[transgohan]

Une technique en utilisant le préprocesseur qui évite d'avoir à dupliquer les sources:

Code :

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

1
2
3
4
5
6
7
8
 
// fichier A
using namespace Foo;
#include "Impl.inc"
 
// fichier B
using namespace Bar;
#include "Impl.inc"

Hum pas sûr de comprendre où vous voulez en venir.
Le but est de créer trois fichiers dans votre exemple non ?
L'un avec le code : Impl.inc
Un autre avec le namespace Foo et l'inclusion de Impl.inc
Et le dernier avec le namespace Bar et l'inclusion de Impl.inc
Mais j'avoue ne pas du tout voir ce que je dois faire avec ces deux fichiers par la suite.

Est-ce ceci ?

Code :

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

1
2
3
4
5
6
7
8
9
void exec(string name){
  if( name == "foo" ){
    using namespace foo;
    #include "someClass.cpp"
  }else{
    using namespace bar;
    #include "someClass.cpp"
  }
}

(Pas les moyens de tester et rien trouvé dans la litterature pouvant s'y rapprocher pour me mettre sur la piste de la compréhension.)

[Jean-Marc.Bourguet]

Hum pas sûr de comprendre où vous voulez en venir.
Le but est de créer trois fichiers dans votre exemple non ?
L'un avec le code : Impl.inc
Un autre avec le namespace Foo et l'inclusion de Impl.inc
Et le dernier avec le namespace Bar et l'inclusion de Impl.inc
Mais j'avoue ne pas du tout voir ce que je dois faire avec ces deux fichiers par la suite.

Est-ce ceci ?

Code :

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

1
2
3
4
5
6
7
8
9
void exec(string name){
  if( name == "foo" ){
    using namespace foo;
    #include "someClass.cpp"
  }else{
    using namespace bar;
    #include "someClass.cpp"
  }
}

(Pas les moyens de tester et rien trouvé dans la litterature pouvant s'y rapprocher pour me mettre sur la piste de la compréhension.)

Par exemple. (Je suis loin d'être sûr que je travaillerais à ce niveau de granularité là, mais l'idée y est).

[transgohan]

Ah bah je viens d'apprendre quelque chose, je pensais naïvement que l'include était réservée pour les fichiers d'entêtes.

[Klaim]

Yavait pas un moyen d'importer une fonction d'un namespace à un autre?


Un truc genre:

Code :

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

1
2
3
4
5
6
7
8
9
namespace A
{
     void truc();
}
 
namespace B
{
     using A::truc();
}

Ca peut pas aider ça? Tu l'écris une fois, tu l'importe dans les namespaces qui sont similaires, tout ça compile-time bien sur.

A vérifier si ça fais bien ce que je pense.

[transgohan]

Pas suivi ce que tu voulais mettre en évidence là.
Tu définis la fonction truc() dans le namespace B qui redirige en fait vers la fonction du namespace A.
C'est bien ça ?
Si j'ai compris le fonctionnement mon raisonnement lui ne va pas plus loin et je vois pas où tu voulais en venir.