Discussion :

[haiecapique]

Bonjour.

Dans un projet, on m'oblige à utiliser une bibliothèque propriétaire très mal codée : elle n'est pas dans un namespace, je n'ai pas accès au code, les fonctions sont très buggée...

Je fait avec et je recode les fonctions buggées, mais j'ai des collisions de noms avec certaines de mes fonctions.
La solution simple mais crade est de renommer mes fonctions pour éviter ces collisions, et adapter tous les appels.
J'aurai préféré rajouter un namespace à la bibliothèque.
J'ai tenté d'entourer l'include dans un nouveau namespace :

Code :

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

1
2
3
4
5
6
7
8
namespace libDuMal {
#include <libToutePourie.h>
};
 
namespace monNamespaceAMoi {
void func_a_jeter_a_la_poubelle() {
    libDuMal::func_a_jeter_a_la_poubelle();
};

Évidemment ça ne marche pas : je me retrouve avec des undefined...

Auriez vous une idée ?
Merci d'avance.

[gbdivers]

Bonjour

Tu peux encapsuler la lib dans un design pattern wrapper :

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
// .h
class LibToutePourieWrapper { // ou namespace
    void foo1();
    void foo2();
};
 
// .cpp
#include <libToutePourie.h>
 
LibToutePourieWrapper::foo1() {
    func_a_jeter_a_la_poubelle1();
}
 
LibToutePourieWrapper::foo2() {
    func_a_jeter_a_la_poubelle2();
}

Comme ça, tu peux :
* isoler complètement les appels de la lib
* facilement réimplémenter une fonction qui bug
* ajouter des pré et post conditions dans tes fonctions pour protéger les appels de la lib

[Bousk]

Bonjour,

essaye avec un using namespace libDuMal; au niveau de l'inclusion de la lib en question.
Peut-être que certains appels en interne de la lib en ont besoin.

Code :

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

1
2
3
4
namespace libDuMal {
using namespace libDuMal;
#include <libToutePourie.h>
};

Peut-on avoir l'erreur exacte ?
S'il s'agit de undefined reference, vérifier les .a/.lib liés à la compilation.

[haiecapique]

Tout d'abord, merci de vos réponses.

@Bousk: c'est bien des erreurs "undefined reference".
Ma lib est bien linké, car si je ne met pas le "#include" entre namespace, tout fonctionne (enfin si je met pas mes redéfinitions...)
Le coup du "using namespace libDuMal;" ne change absolument rien.


@gbdivers: ton idée est intéressante, mais elle m'oblige à changer tous les appels, et de redéfinir toute les fonctions de la lib.
Autant dire que c'est un travail titanesque.
Enfin peut être pas en remplaçant le classWrapper par un namespaceWrapper et en utilisant le "using namespaceWrapper;".
Je vais tester.

[haiecapique]

Ça a l'air de fonctionner :

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
 
// LibToutePourieWrapper.h
namespace LibToutePourieWrapper {
    void func_a_jeter_a_la_poubelle1();
    void func_a_jeter_a_la_poubelle2();
};
 
// LibToutePourieWrapper.cpp
#include <libToutePourie.h>
 
LibToutePourieWrapper::func_a_jeter_a_la_poubelle1() {
    func_a_jeter_a_la_poubelle1();
}
 
LibToutePourieWrapper::func_a_jeter_a_la_poubelle2() {
    func_a_jeter_a_la_poubelle2();
}
 
// Utilisation.cpp
#include "LibToutePourieWrapper.h"
 
using namespace LibToutePourieWrapper;
 
func_a_jeter_a_la_poubelle1();

Donc j'ai juste à changer les includes dans tout mon projet, et a redefinir les methodes buggée dans mon wrapper.
Merci beaucoup.

[gbdivers]

Idéalement, c'est vrai que il aurait fallut encapsuler dès le départ.
Mais oui, tu peux simplement créer ton namespace et garder les mêmes noms de fonctions. Mais attention : ne mélange surtout pas l'appel directe à la lib et l'appel en passant par le wrapper, sinon ça sera ingérable rapidement. Donc 1 seul include de ta lib : dans le cpp du wrapper et c'est tout (fait une recherche multifichier pour vérifier que tu n'as pas d'autres include qui trainent

[haiecapique]

Oui, logique tout doit passé par le wrapper, pour être sur que c'est les fonctions modifiée qui sont exécutées. Enfin ça reste dommage de pas pouvoir encapsuler une lib qu'on ne maitrise pas...
Peut être dans la prochaine norme