Discussion :

[spender]

Bonjour,
Je m'attaque au portage d'un application existante vers Unicode.
Je suis sous Visual C++ Embedded 4 et j'ai bien la propriété unicode dans les settings du projet.
Actuellement, j'ai un CEdit, je récupère son contenu que je met dans un char* puis je l'envoi à une autre appli via une socket. Ensuite, dans l'autre sens, je reçois un char* via une socket puis je l'affiche dans un CEdit. Le but désormais est d'échanger de l'unicode (format utf-8) avec cette seconde appli.
Comment (avec quel type et méthode) puis-je passer du contenu du CEdit à un char* en passant par un encodage utf-8 et vice versa ?
Merci d'avance pour votre aide.

[Médinoc]

Je ne connais pas trop Embedded, mais traditionnellement sous Windows on utilise les fonctions libres MultiByteToWideChar() et WideCharToMultiByte() avec le paramètre CP_UTF8.

J'ignore s'il y a plus évolué sous MFC, ni ce que permet ta version de MFC. Dans cette version, CString est-elle une classe ou y a-t-il le template CStringT?

[spender]

Bonjour,

Merci Médinoc pour la réponse.

Je ne pense pas que CStringT, CStringA ou CStringW soient disponibles car ça a été implémenté après VC++ 6 d'après ce que dit la faq et là moi je suis sur une base de 4....
Je me suis en effet tourné vers les méthodes MultiByteToWideChar() et WideCharToMultiByte() mais elles sont délicates à utiliser et je ne m'en sors pas pour le moment avec ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
LPWSTR orgUnicode = L"Coucou";
LPSTR destUTF8 = NULL;
//Unicode vers UTF-8
WideCharToMultiByte(CP_UTF8, 0, orgUnicode, 6, destUTF8, 7, NULL, NULL); 
 
orgUnicode = L"";
 
//UTF-8 vers Unicode
MultiByteToWideChar(CP_ACP, 0, destUTF8, 7, orgUnicode, 7); //wcslen(orgUnicode));

Une idée de ce qui pourrait clocher ?

Merci d'avance pour votre aide.

[Médinoc]

Pour faire une conversion, il faut deux appels à la même fonction:

• Un avec un buffer nul, pour connaître la taille de buffer à allouer,
• Et un avec un buffer fraichement alloué avec la bonne taille.

[Médinoc]

Pour la conversion vers Unicode, je m'étais fait cette fonction. Elle est plus compliquée que le strict nécessaire, mais elle est en C, retourne un HRESULT cas d'erreur et donne la taille de la chaîne en cas de succès:

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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/* Get a HRESULT from a Win32 error code, or E_UNEXPECTED */
static HRESULT GetHResultFromWin32(DWORD error)
{
	HRESULT hr = HRESULT_FROM_WIN32(error);
	if(SUCCEEDED(hr))
		hr = E_UNEXPECTED;
	return hr;
}
 
/* Convert a char string into an unicode string. */
HRESULT GetUnicodeString(
 LPCSTR sczInA,    /*[in] char string.*/
 UINT codePage,    /*[in] Code page identifier, or CP_ACP etc.*/
 LPWSTR * pSzOutW, /*[out] Receives a pointer to the new wide character string.*/
 int * pCchWritten /*[out/opt] If set, receives the length of the wide character string, in characters. */
 )
{
	HRESULT hrRet = E_UNEXPECTED;
	int cchSizeW = 0;
 
	/*Initialize optional output parameters to their default values*/
	if(pCchWritten != NULL)
		*pCchWritten = 0;
	/*Test other output parameters, and initialize to their default values as long as possible*/
	if(pSzOutW==NULL)
		return E_POINTER;
	*pSzOutW = NULL;
 
	/*Test input parameters*/
	if(sczInA==NULL)
		return E_INVALIDARG;
 
	/*Calculate size*/
	cchSizeW = MultiByteToWideChar(codePage, MB_ERR_INVALID_CHARS, sczInA, -1, NULL, 0);
	if(cchSizeW <= 0)
		hrRet = GetHResultFromWin32(GetLastError());
	else
	{
		/*Alloc buffer*/
		LPWSTR szOutW = malloc(cchSizeW * sizeof *szOutW);
		if(szOutW==NULL)
			hrRet = E_OUTOFMEMORY;
		else
		{
			/*Use buffer*/
			BOOL bKeepMem = FALSE;
			int cchWritten = MultiByteToWideChar(codePage, MB_ERR_INVALID_CHARS, sczInA, -1, szOutW, cchSizeW);
			if(cchWritten <= 0)
				hrRet = GetHResultFromWin32(GetLastError()); /*This error is very unlikely to happen, since it was tested before*/
			else
			{
				/*OK!*/
				hrRet = S_OK;
				bKeepMem = TRUE;
				*pSzOutW = szOutW;
				if(pCchWritten!=NULL)
					*pCchWritten = cchWritten;
			}
 
			if(!bKeepMem)
				free(szOutW);
		}
	}
	return hrRet;
}
 
/* Delete a wide character string allocated by GetUnicodeString() */
HRESULT FreeUnicodeString(LPWSTR szDelW)
{
	if(szDelW==NULL)
		return S_FALSE;
	free(szDelW);
	return S_OK;
}

J'ai aussi en stock une version de cette fonction qui donne une BSTR à la place.

[ram-0000]

Pour faire une conversion, il faut deux appels à la même fonction:

• Un avec un buffer nul, pour connaître la taille de buffer à allouer,
• Et un avec un buffer fraichement alloué avec la bonne taille.

J'avais optimisé un peu la chose.

Le premier appel, je donnais un buffer dont la taille était arbitraire (32 caractères), et je traitais les cas d'erreur. En cas d'erreur "buffer pas assez grand", je réallouais à la taille demandée et je faisais le deuxième appel.

J'ai remarqué que dans la majorité des cas, j'économisais ainsi 1 appel.

[spender]

Bonjour,

Merci Médinoc et ram-0000 pour vos réponses.
Je vais donc tester la méthode du double appels successifs et vous tiendrai informé du résultat.