Discussion :

[azias]

Bonjour,

Pour un projet C++ je dois inclure deux bibliothèques statiques C++, et il se trouve qu'elles proposent des classes qui ont le même nom.

J'ai bien évidemment l'intention d'utiliser les namespace pour les différentier au niveau du code, mais ces bibliothèques ont été programmées sans namespace.

Est-ce que quelqu'un sait comment il pourrait être possible d'ajouter un namespace englobant pour chaque bibliothèque?

Et sinon est-ce vous auriez une idée pour contourner le problème?

Merci

[r0d]

Bonjour,

c'est un problème délicat en effet.
Pour ma part, si tu ne peux pas modifier le source de ces libs, je ne vois pas d'autre solution que de créer un wrapper. C'est à dire une classe qui reproduit l'interface de chaque lib, se contentant d'appeler les fonctions de chaque lib. En prenant soin de ne surtout pas inclure les en-tête de ces libs dans les en-têtes de tes wrappers.

Par exemple:

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//lib1.h
void fonction();
 
//lib2.h
void fonction();
 
//WrapperLib1.h
namespace Lib1
{
   void fonction_lib1();
}
 
//WrapperLib1.cpp
#include "lib1.h"
#include "WrapperLib1.h"
namespace Lib1
{
   void fonction_lib1()
   {
      fonction(); //puisqu'ici il ne connais que lib1.h, il appelera la fonction() de lib1
   }
}
 
//WrapperLib2.h
namespace Lib2
{
   void fonction_lib2();
}
 
//WrapperLib2.cpp
#include "lib2.h"
#include "WrapperLib2.h"
namespace Lib2
{
   void fonction_lib2()
   {
      fonction(); //puisqu'ici il ne connais que lib2.h, il appelera la fonction() de lib2
   }
}

C'est très lourd, surtout s'il y a beaucoup de choses à emballer (to wrap), mais je ne vois pas d'autre solution.
Peut-être quelqu'un ici en connait d'autres?

[azias]

Bonjour,

Désolé de répondre aussi tardivement.

En fait comme je le disais ce ne sont pas des fonctions (quoi qu'il y en a aussi) mais surtout des classes donc je ne sais pas si ça peut fonctionner de la même façon.

Heureusement pour moi j'ai accès aux sources, mais j'aurais bien aimé pouvoir éviter d'aller modifier les sources car ce n'est pas moi qui les maintient. Une vingtaine de fichiers auxquels il faur ajouter des namespaces à la main, et recommence à chaque fois que la personne en charge de la maintenant ces fichiers les modifie.

En plus je ne peux pas demander à ce que le namespace soit ajouté une fois pour toute dans l'original puisque si j'ai j'ai besoin de gérer des bibliothèques qui ont des noms de classe en commun c'est en fait parce qu'elles ont quasi exactement les mêmes classes: il s'agit d'un outils qui doit gérer les versions successives de ces classes, donc les naissances doivent changer à chaque version.

Il n'y a donc pas de moyen en C++ de «packager» des bibliothèques avec un mécanisme qui permet d'être certain «d'isoler» les bibliothèques? sans avoir à réécrire toutes les interfaces j'entend.


Merci

[Davidbrcz]

Je pencherai vers une solution similaire à celle de r0d mais beaucoup moins fastidieuse que la sienne avec quelque chose du genre suivant

file1.h

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
16
#ifndef FILE_H 
#define FILE_H 
 
class A
{
public:
    A(){std::cout<<"A cst"<<std::endl;}
    ~A(){std::cout<<"A dst"<<std::endl;}
};
 
void bar()
{
    std::cout<<"foo"<<std::endl;
}
 
#endif

file2.h

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
16
#ifndef FILE2_H 
#define FILE2_H 
 
class A
{
public:
    A(){std::cout<<"A2 cst"<<std::endl;}
    ~A(){std::cout<<"A2 dst"<<std::endl;}
};
 
void bar()
{
    std::cout<<"foo2"<<std::endl;
}
 
#endif

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
16
17
18
19
20
21
#include <iostream>
 
namespace foo
{
#include "file.h"
}
 
namespace foo2
{
#include "file2.h"
}
 
int main(int argc, char const *argv[])
{
    foo::A test;
    foo::bar();
 
    foo2::bar();
    foo2::A a;
    return 0;
}

Après il faut enrober correctement chaque namespace dans un header comme il faut et n'inclure plus qu'eux. Il ne doit plus avoir dans ton code aucune trace de file{1,2}.h

Après tu peux automatiser le coup à coup de métaprog et autres siouries du genre boost:: PP soit à coup de script bash que tu lances avant l'exécution pour être sûr que tout va bien comme il faut.

Ceci n'étant qu'un hack, l'idéal ca reste quand même de demander un namespace dans la bibliothèque de base.

[Feriaman]

Une vingtaine de fichiers auxquels il faur ajouter des namespaces à la main, et recommence à chaque fois que la personne en charge de la maintenant ces fichiers les modifie.

Bonjour,

Tu ne peux pas expliquer au type qu'il devrait utiliser un namespace ?

Quand je peux me le permettre, je permets de faire un gros effort pour me mettre dans de "bonnes" conditions, plutôt qu'un petit effort pour arriver à travailler dans de mauvaises.

Le danger des solutions de contournements, c'est qu'à force d'en ajouter à d'autres, la situation ne fait qu'empirer jusqu'au moment où elle est insupportable.

En l'occurrence, si tu as le problème et que tu le contourne, tu peux être sur que d'autres auront le problème et s'inspireront de ce que tu fais pour le contourner ... puis viendront sans doute des contournements de niveaux 2, puis de niveau 3 et à la fin ==> poubelle.

Alors qu'encapsuler 20 classes dans un namespace, ça me semble plus pérenne et pas très fatiguant.

Je pencherai vers une solution similaire à celle de r0d mais beaucoup moins fastidieuse que la sienne avec quelque chose du genre suivant ...

Nice ! je n'avais jamais vu cette pratique. C'est une façon rapide de contourner le problème.
N'y a-t-il pas quelque chose à gérer au niveau du link pour que ça marche ?

[Invité]

Je crois qu'il faut aussi enrober les sources et les recompiler :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
//file.cpp
namespace foo
{
 
#include "file.h"
#include "autreinclude.h"
 
// et le reste du fichier
 
}

[azias]

je repasse juste pour marqué résolu ce vieux sujet.

Mon problème de départ n'étant pas d'utiliser deux bibliothèques différentes de même nom mais bien deux versions différentes (en fait 3,4..., de plus en plus) de la même bibliothèque afin de les faire travailler ensemble, il n'était pas possible de fixer un namespace unique dans le code de départ.

La solution a consisté à ajouter les namespace (ou renommer les namespace s'ils étaient déjà présents) pour chaque version. Au passage j'en profite pour faire un grand ménage dans le code puisque que je n'utilise qu'une partie de la bibliothèque.

Merci.