27 votes

Partage d'une variable globale/statique entre un processus et une DLL

J'aimerais partager une variable statique/globale uniquement entre un processus et une dll qui est invoquée par le processus. L'exe et la dll sont dans le même espace d'adressage mémoire. Je ne veux pas que la variable soit partagée entre d'autres processus.


Élaboration du problème :

Disons qu'il existe une variable statique/globale x en a.cpp . Les deux exe foo.exe et la dll bar.dll ont a.cpp donc la variable x est dans les deux images.

Ahora, foo.exe charge dynamiquement (ou statiquement) bar.dll . Le problème est alors de savoir si la variable x est partagé par l'exe et la dll, ou non.

Dans Windows, ces deux gars jamais partager le x : l'exe et la dll auront une copie séparée de x . Cependant, sous Linux, l'exe et la dll partagent la variable x .

Malheureusement, je veux le comportement de Linux. J'ai d'abord envisagé d'utiliser pragma data_seg sur Windows. Cependant, même si je configure correctement le segment de données partagé, foo.exe y bar.dll ne partage jamais le x . Rappelons que bar.dll est chargé dans l'espace d'adressage de foo.exe . Cependant, si je lance une autre instance de foo.exe entonces x est partagé. Mais, je ne veux pas x pour être partagé par différents processus. Ainsi, en utilisant data_seg a échoué.

Je peux utiliser un fichier mappé en mémoire en créant un nom unique entre exe et dll, ce que j'essaie maintenant.


Deux questions :

  1. Pourquoi le comportement de Linux et de Windows est-il différent ? Quelqu'un peut-il nous en dire plus à ce sujet ?
  2. Quel serait le moyen le plus simple de résoudre ce problème sous Windows ?

1voto

Zeeshan Points 11

J'ai examiné ces options et j'ai décidé d'implémenter le singleton inter-modules en utilisant la mémoire partagée et cela a bien fonctionné pour moi aussi. J'ai utilisé Qt QSharedMemory pour réaliser ma tâche mais le prototype que j'ai écrit en utilisant le Win32 CreateFileMapping & etc.

0voto

zdan Points 11822

Si je comprends bien votre question, vous liez statiquement a.cpp à foo.exe et bar.dll, ce qui vous donne deux instances de x.

Si vous créez une troisième dll (disons a.dll), et que vous liez dynamiquement foo.exe et bar.dll à a.dll, vous obtiendrez le comportement que vous souhaitez :

  1. foo.exe charge a.dll et crée x.
  2. bar.dll est chargé et voit que a.dll est chargé et ne le charge pas à nouveau, ils partagent x.
  3. Un autre processus charge a.dll, il obtient son propre x.

0voto

Michael Haephrati Points 145

J'ai vu de nombreuses réponses à cette question et comme elle est un peu délicate et peu claire, je voudrais apporter le scénario suivant. Nous voulons partager une variable globale entre une DLL et un programme principal, et aussi permettre l'accès à cette variable à partir de différents modules dans la DLL et dans le programme principal.

La variable est un BOOL indiquant si le programme doit continuer à fonctionner ou s'arrêter. Le nom de la variable est ShouldRun ;

Dans le programme principal, nous devons mettre :

__declspec(dllexport)  bool ShouldRun;

Dans le module principal de la DLL, nous devons mettre :

extern "C" BOOL __declspec(dllexport) ShouldRun = TRUE;

Dans tout autre module à l'intérieur du projet DLL que nous utiliserons :

extern  "C" BOOL ShouldRun;

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X