[MFC] conversion void * en variant

Bonjour, je converti un VARIANT en void* pour le faire passer dans une socket ( via un buffer)

ce code pour la conversion en void* marche

Code:

---

1 2 3 4

SafeArray.Attach(SampleArray); SafeArray.AccessData(&pBuffer); dwBufferSize = SafeArray.GetOneDimSize();

---

SafeArray est de type COleSafeArray ;
SampleArray est un VARIANT &
pbuffer est un void*


cela dit, je n'arrive pas à faire l'opération inverse. ( donc de passer de void* à VARIANT)

Tu dois créer un SAFEARRAY de la bonne taille, puis faire un AccessData() pour pouvoir y écrire.

nan ben j'arrive pas, en plus ça doit tenir sur 3 lignes, t'aurais pas un peu plus de précisions, voir un sample de code?

Un truc du genre:

Code:

---

1 2 3 4

recv(&dwBufferSize); SafeArray.Redim(dwBufferSize); SafeArray.AccessData(&pBuffer); recv(pBuffer);

---

j'ai fait ça, mais ça plante après quand var est utilisé.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

VARIANT var; VariantInit(&var); / COleSafeArray SafeArray2; SAFEARRAYBOUND rgsabound[1]; rgsabound[0].cElements = 10000; rgsabound[0].lLbound = 0; SafeArray2.Redim(rgsabound); SafeArray2.AccessData((void **)buf); var = SafeArray2.Detach(); // Pour essayer d'avoir un variant

---

Je ne vois pas la déclaration de buf, mais je pense qu'il manque un '&' :

Code:

---

SafeArray2.AccessData((void **)&buf);

---

ça marche toujours pas, voici le code de test si tu veut voir

Code:

---

1 2 3

Code supprimé pour cause de licences

---

Citation:

---

Envoyé par Médinoc

Un truc du genre:

Code:

---

1 2 3 4

recv(&dwBufferSize); SafeArray.Redim(dwBufferSize); SafeArray.AccessData(&pBuffer); recv(pBuffer);

---

---

Ouh là, réviser (ou apprendre..) les bases du C, parce que là....

Quand j'écris du pseudocode, je me moque des bases du C.
De plus, le code est en C++ avec MFC (COleVariant, COleSafeArray...).

Bon ben moi en tout cas ça marche toujours pas, c'est vraiment de la merde les MFC, vive .net !

ça compile, mais le variant d'arrivé n'est pas le même ce qui fait que mon buffer ne s'affiche pas...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

VARIANT var; VariantInit(&var); // COleSafeArray SafeArray2; SAFEARRAYBOUND rgsabound[1];   rgsabound[0].cElements = dwBufferSize; rgsabound[0].lLbound = 0; SafeArray2.Create(VT_VARIANT,1, rgsabound);   SafeArray2.AccessData(&buf); SafeArray2.UnaccessData(); var = SafeArray2.Detach();

---

Attends, c'est un safearray de variant que tu transmets comme ça ?

Mauvais. Plusieurs types de variant ne sont pas directement transmissibles sur le réseau. Tu ne peux transmettre que des types "plats" (int, byte, etc.).

Pour l'instant je test en local en renvoyant un variant converti en void* dans une autre méthode.


Dans la méthode qui convertit le VARIANT en type transmissible ( void*):

Code:

---

1 2	Code supprimé pour cause de licences

---

Dans la méthode lire(void* pBuffer) qui converti les donnée transmises (void *) en VARIANT :

Code:

---

1 2	Code supprimé pour cause de licences

---

Un pointeur est tout sauf un type transmissible, car il n'est valide que dans son processus.

Tu dois comprendre le concept de sérialisation avant de t'attaquer à la transmission de données complexes par un réseau.

Je connais un peut la sérialisation, mais la je ne vois pas comment l'appliquer...


A tu des liens vers de bon tutos, etc...

Je ne connais pas de tutos, mais la règle générale, c'est de tout transformer en une suite d'octets ne contenant aucun pointeur (sauf concept de marshalling par référence)

En l'occurrence, pour les pointeurs, ça veut dire qu'on transmet les données pointées à la place, de préférence en commençant par leur taille si elle est variable.

Exemple: Une structure contenant un pointeur vers N autres structures, et une chaîne de caractères:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct a { int toto; float tata; };   struct b { struct a *pa; /*Ici, on va dire trois structures contenant 1, 2, 3*/ int nbrA; char * str; /*Ici, on va dire "coucou" */ };

---

Devra être transmis ainsi:

• nbrA ( 3 )
• pa[0].toto (1)
• pa[0].tata (1.0f)
• pa[1].toto (2)
• pa[1].tata (2.0f)
• pa[2].toto (3)
• pa[2].tata (3.0f)
• strlen(str) (6)
• str[0] = ('c')
• str[1] = ('o')
• str[2] = ('u')
• str[3] = ('c')
• str[4] = ('o')
• str[5] = ('u')

Tu remarqueras qu'il n'y a aucun pointeur dans les données transmises.

Si on transmet en big-endian avec des types 32 bits, ça donne ceci (en hexa) :
00 00 00 03 00 00 00 01 3F 80 00 00 00 00 00 02 40 00 00 00 00 00 00 03 40 40 00 00 00 00 00 06 63 6F 75 63 6F 75