Bonjour tout le monde,  
 
Je dois faire communiquer deux programmes ( en c++) et j'ai choisi pour cela la mémoire partagée (windows only).
Après quelques recherches, je me suis mis à essayer d'adapter le code exemple de la msdn:
http://msdn.microsoft.com/en-us/li [...] S.85).aspx
 
Mon principal souci sont ces _t intempestifs dont je ne comprend pas la signification. (Cela servirait pour faire en format Unicode, mais encore?), cela ne m'aide pas à essayer d'utiliser la fonction CopyMemory():
 
En effet CopyMemory ne reçoit que des types tchar const (tchar?) or je voudrai envoyer des tableaux d'entiers, des chaines et des structures).  
(j'ai essayer de faire des casts mais il y a des violations mémoire au pire, le contenu est illisible par un programme tiers au mieux.)
Bref je ne sais pas si mon approche est la bonne ou si il y a éventuellement d'autres moyens auxquels je n'ai pas pensé.
en vous remerciant d'avance!

Pour ton problème d'utilisation de ta mémoire partagée, poste ton code.
Y'a que comme ça qu'on pourra t'aider a refactoriser tes échanges de données entre process.

----

Après pour l'aspect gestion des mémoires partagées, je te conseillerai comme d'habitude ici boost.

boost::interprocess::windows_shared_memory, si tu veux une gestion de la vie de la mémoire partagée à la Windows (plus de handles => l'os delete la mémoire partagée)

Le portage sera toujours plus facile sous un autre OS par la suite.

Merci de ton intervention,
 je n'ai pas posté mon code car il est une quasi reproduction de la msdn (je fais une programme test avant de l'implémenter); Néanmoins voilà le code issue du lien posté plus haut:
 
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
 
#define BUF_SIZE 256
TCHAR szName[]=TEXT("Global\\MyFileMappingObject" );
TCHAR szMsg[]=TEXT("Message from first process." );
 
int _tmain()
{
   HANDLE hMapFile;
   LPCTSTR pBuf;
 
   hMapFile = CreateFileMapping(
                 INVALID_HANDLE_VALUE,    // use paging file
                 NULL,                    // default security  
                 PAGE_READWRITE,          // read/write access
                 0,                       // max. object size  
                 BUF_SIZE,                // buffer size  
                 szName);                 // name of mapping object
 
   if (hMapFile == NULL)  
   {  
      _tprintf(TEXT("Could not create file mapping object (%d).\n" ),  
             GetLastError());
      return 1;
   }
   pBuf = (LPTSTR) MapViewOfFile(hMapFile,   // handle to map object
                        FILE_MAP_ALL_ACCESS, // read/write permission
                        0,                    
                        0,                    
                        BUF_SIZE);            
 
   if (pBuf == NULL)  
   {  
      _tprintf(TEXT("Could not map view of file (%d).\n" ),  
             GetLastError());  
 
    CloseHandle(hMapFile);
 
      return 1;
   }
 
   
   CopyMemory((PVOID)pBuf, szMsg, (_tcslen(szMsg) * sizeof(TCHAR)));
    _getch();
 
   UnmapViewOfFile(pBuf);
 
   CloseHandle(hMapFile);
 
   return 0;
}
 
Ca marche bien avec le programme client mais je voudrai adapter cette fonction:
CopyMemory((PVOID)pBuf, szMsg, (_tcslen(szMsg) * sizeof(TCHAR)));
  //  _getch();
 
pour qu'au lieu de szMsg (qui est un tableau static w_chart) je puisse mettre une structure, ou des entiers.

Tu as deux étapes: déjà avoir une idée de ce que tu vas devoir passer en termes de volumes, pour savoir quelle dimension donner à ta mémoire partagée.
 
Ensuite bah il y a plusieures manières de voir le passage de données, ça peut être vu comme un problème de sérialisation, comme tu peux gruger en faisant des assignements via des casts si tes types/classes sont triviaux. Toutes les solutions sont possibles
 
Pour trancher c'est le reste du code, et ce que tu veux y mettre qu'il faut avoir.
 
Donc décrits tes types et l'utilisation que tu comptes avoir de la mémoire partagée.

Ce que je compte faire passer en mémoire partagée ce sont 3 tableaux alloués dynamiquement: l'un d'entier, l'autre de booléens, le dernier de chaines de caractères.  
 
Initialement, j'avais une dll avec des variables partagées dessus, c'était très simple et ça marchait, seulement on ne pouvait y mettre de pointeur (car sinon le contenu des pointeur étaient en dehors de la zone de mémoire)   , donc j'ai jeté mon dévolu sur la mémoire partagée mais je me demande si c'est vraiment performant: quand je vois les fonctions nécessaire pour convertir un entier en w_chart  j'imagine pas l'appliquer pour tout mon programme.  

t'as benché avant de dire ça Punaise, la tonne de premature optimizer ces temps çi

Sur quel critère se basé pour savoir si  on a une premature optimizer

? je comprend pas ce que vous dites!

vouloir optimisé des bribes de code sans avoir fait de profiling en se basant a l'instainct.
C'ets la pire des choses à faire.

 
Qué ?
 
Une mémoire partagée est une mémoire partagée. Y'a rien à convertir, tu peux pas avoir plus rapide comme accès partagé a des données.

 
Le problème n'est pas là, le problème est que Vings ne sait pas ce qu'il veut faire.

 
je parlais de ça remarque sur le temps d'exécution

Y a t'il moyen de revenir à mon problème premier? Je demande pas mieux d'utiliser la mémoire partagée, mais j'ai comme vous avez pu le remarquer je suis un débutant en la  matière.
Mon problème se situe au niveau de la fonction CopyMemory(), je me suis mal exprimé d'ailleurs à ce propos, je ne voulais pas tant parler de performance que du caractère laborieux de son emploi (enfin pour le peu que j'en ai vu, et je n'y connais pour ainsi dire rien). J'essaie en vain d'adapter le code de la MSDN pour envoyer autre chose qu'une chaine de caractère constante, la serialisation est en effet une piste, mais je ne vois pas comment la réaliser.
 
Avez vous un lien sur un tutorial par exemple? ça m'aiderait grandement! Car je crois être passé à côté des fondamentaux.  
merci d'avance!

http://www.google.fr/search?hl=fr& [...] 9e&spell=1
 

 
Ce qu'il faut c'est que tu vois des exemples d'échanges à travers une mémoire partagée.
 
Mais y'a rien de spécial, au final c'est un espace comme un bloc mémoire alloué par un malloc() , donc à toir de voir comment la remplir....

 
Merci mais j'ai bien cherché sur le net et je ne trouve rien de probant depuis 3 jours, en tout cas pour la manière que je cherche    
En effet, j'aurai bien voulu adapter l'exemple de la msdn, car ça me semble plus facile de le marshaller pour une application c#. C'est ça qui me semble bizarre: ne pas pouvoir adapter cet exemple. Enfin bon je vais continuer à chercher et tester, ça finira bien par s'éclaircir.  
Dans tous les cas merci de vos interventions.

C# != C++ aussi.
Regarde boost::interprocess et ca sera plus simple je pense

 
Y'a rien à faire. Une création de mémoire partagée reviens à une allocation. A toi de déposer et d'aller chercher ce dont tu as besoin...
Si tu as juste à synchroniser quelques états, tu as fais ta structure, tu crées ta mémoire partagée et tu maintiens un pointeur de structure sur la mémoire partagée et basta....
T'as besoin de pousser un volume variable, tu crées une mémoire partagée qui tiens ta structure d'état et de la marge pour tenir une certaine quantitée de données, et tu fais ton petit mécanisme de producteur/consommateur synchronisé par sémaphore ou mutex (ou peut-être rien).
 
Enfin c'est presque comme un malloc(), à toi de savoir combien tu as besoin, et ce que tu vas en faire.
 

Bon j'ai choisi de faire du filemapping, je n'aurai pas de problème particulier si je n'avai pas à l'utiliser à partir d'une interface en c#.
Pour ce faire, je recycle ma dll en c++ qui sert de support aux fonction destiner à manipuler la mémoire partagée, mais j'ai un problème pour lire les données.
 
En effet il me faut marshaller la structure de donnée et il apparait que je me débrouille mal (exception Safe Array type Missmatch).
 
Voila le code
 

 
Si vous avez des idées...

up!

up!