Chargement dynamique des lib

[BenjaminVS]

Bonjour.

J'ai un projet dans lequel j'ai utilisé windows.h sous seven pour l'utilisation de la structure WM_TOUCH et des méthodes spécifiquement Win7 comme GetTouchInputInfo.
Le problème est que j'aimerais pouvoir compiler sous XP.
On a pu me parler du chargement dynamique et le problème est que je ne sais absolument pas comment cela pourrait fonctionner.
J'ai juste pu voir que je devais redéclarer les fonctions comme par exemple :
GetTouchInputInfo libWindows::my_GetTouchInputInfo = NULL;
J'ai aussi des structures de données Win7 (WM_TOUCH) et des macros.

Merci
Benjamin

[Rewpparo]

Je ne connais pas vraiment la prog windows, mais si tu veux que ca compile sous wndows XP, il faut que tu trouves un moyen de détecter en préprocesseur la version de windows, et faire un #define pour le signaler.
Ensuite entoures le code typique windows 7 comme ceci :

Code :

1
2
3
#ifdef WINDOWS_7
///Code typique de windows 7
#endif

Ca c'est la version "C", qui marche bien pour des petits programmes. Dans la version C++, il vaut que tu isoles le code Windows 7 dans des classes avec une interface virtuelle, et que tu en fasses plusieurs implémentations, une pour windows 7 et une pour windows XP, et tu choisis à la compilation laquelle tu utilises.

[BenjaminVS]

Merci,
C'est en effet ce que je fait :
"isoler le code Windows 7 dans des classes avec une interface virtuelle". Il faut donc que je refasse ma propre implémentation des fonctions utilisées sur seven?

Merci pour l'aide

[Rewpparo]

Plusieurs options.
Si ton code peut tourner sans les fonctionnalités windows 7, soit tu fais sans, soit tu les rend optionnelles, c'est a dire que tu t'arrange pour que ca se greffe sur le reste, si c'est pas la on fait sans.

Si ton code ne peut pas tourner sans les fonctionnalités windows 7, alors pèse bien ta décision de permettre une compilation windows XP. Si tu choisis de poursuivre alors il te faudra ré implémenter les fonctionnalités Windows 7 avec du code XP... Et alors pourquoi utiliser les fonctionalités windows 7 ? Garde ton implémentation pour XP sous windows 7, ca t'évitera de devoir tester sous les deux OS.

[ram-0000]

Il est possible de travailler de 2 manières différentes.

Soit tu fais 2 binaires différents avec du "#ifdef SEVEN"/ #endif", un binaire pour XP et un binaire pour Seven. La différence se fait à la compilation, c'est dans la grandes lignes ce que décrit Rewpparo.

Tu peux aussi faire un seul binaire dont le comportement est différent suivant la présence ou non d'une fonction ou d'une API. Pour cela, il faut connaitre la fonction et surtout la DLL dans laquelle est est implémentée. Heureusement, le MSDN donne toutes ses informations.

On va partir sur un exemple avec la fonction EnterSynchronizationBarrier() qui n'est disponible qu'en Windows 8. Le MSDN donne la signature de la fonction :

Code :

1
2
3
4
BOOL  WINAPI EnterSynchronizationBarrier(
  _Inout_  LPSYNCHRONIZATION_BARRIER lpBarrier,
  _In_     DWORD dwFlags
);

ainsi que la DLL dans laquelle elle est implémentée ==> Kernel32.dll.

La première chose à faire consiste à déclarer un type pointeur de fonction et une variable pour cette fonction

Code :

1
2
3
4
5
6
 
// cette écriture peut sembler un peut barbare au 1er abord mais c'est comme cela
typedef BOOL WINAPI ( * EnterSynchronizationBarrier_fct)(_Inout_ LPSYNCHRONIZATION_BARRIER lpBarrier, _In_ DWORD dwFlags);
 
// ma_fonction est un pointeur de fonction sur la fonction EnterSynchronizationBarrier de la DLL kernel.dll
EnterSynchronizationBarrier_fct ma_fonction = NULL;

La seconde chose consiste à charger la dll

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
HMODULE mon_module LoadLibrary(_T"kernel32.dll");
if(mon_module != NULL)
{
   // la DLL existe
   // chargement de la fonction
   ma_fonction = GetProcAddress(mon_module, "EnterSynchronizationBarrier");
   if(ma_fonction == NULL)
   {
      // la fonction existe, on peut l'utiliser
   }
   else
   {
       // la fonction n'existe pas dans la DLL, il faudra faire sans cette fonction spécifique
   }
}
else
{
   // la DLL n'existe pas, il faudra faire sans cette fonction spécifique
}

et enfin, tu peux utiliser ta fonction

Code :

1
2
3
4
5
6
7
8
9
10
if(ma_fonction != NULL)
{
   // initialisation des parametres Barrier et flags
   ...
   BOOL ret = ma_fonction(&Barrier, flags);
}
else
{
   // la fonction n'existe pas, on n'a donc pas le droit de l'appeler, il faut faire sans
}

à la fin de ton programme ou bien quand tu es sûr que tu n'as plus besoin d'appeler cette fonction, il faut décharger la DLL

Code :

1
2
3
4
5
if(mon_module != NULL)
{
   ma_fonction = NULL
   FreeLibrary(module);
}

Ce code va se compiler sans problème et tu auras un seul binaire pour toutes les versions Windows. Le binaire va sans charger sans difficulté et sans problème de "missing DLL". Par contre, le comportement sera différents suivant la présence ou non des fonctions.

PS : tu as tout intérêt à encapsuler ce code dans une classe spécifique

[BenjaminVS]

Oui merci, c'est ce que j'ai fait, à peu près, dans une classe.

Merci pour votre aide