Discussion :

[dfiad77pro]

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 :

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

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)

[Médinoc]

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

[dfiad77pro]

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?

[Médinoc]

Un truc du genre:

Code pseudocode :

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

1
2
3
4
recv(&dwBufferSize);
SafeArray.Redim(dwBufferSize);
SafeArray.AccessData(&pBuffer);
recv(pBuffer);

[dfiad77pro]

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

Code :

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

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

[Médinoc]

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

Code C++ :

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

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

[dfiad77pro]

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

Code c++ :

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

1
2
3
 
 
Code supprimé pour cause de licences

[Greg93]

Un truc du genre:

Code pseudocode :

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

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à....

[Médinoc]

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

[dfiad77pro]

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

[dfiad77pro]

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

Code c++ :

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

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();

[Médinoc]

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.).

[dfiad77pro]

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 c++ :

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

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 c++ :

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

1
2
 
Code supprimé pour cause de licences

[Médinoc]

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.

[dfiad77pro]

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...

[Médinoc]

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 C :

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

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