Discussion :

[olivier21c]

Bonjour,

Je reçois en entrée un string contenant des caractères spéciaux sous la forme par exemple %C3%A9.
Je voudrais convertir les caractères de cette chaîne pour avoir plutôt des caractères comme é.
Pour info, ce string correspond au chemin d'un fichier que je dois ouvrir.

Je n'ai pas de contrôle sur la chaîne en entrée.
Je préférerai une méthode sans librairie externe, dans un soucis d'utilisation de licence.

Merci d'avance

[Médinoc]

Ça dépend dans quel format il te faut ton nom de fichier.
S'il te le faut en UTF-8 ce ne sera pas un problème; sinon ta conversion aura besoin d'une étape de plus.

Les bonnes nouvelles sont:

• Les seules séquences valides pour conversion sont en ASCII pur, donc on n'a pas vraiment à se soucier du reste pour la chaîne d'entrée.
• La chaîne en sortie ne peut pas être plus grande que celle en entrée, donc pas de problèmes de taille de buffer.

Commence à coder ta fonction, poste ton code si tu te retrouves bloqué.

[dragonjoker59]

Salut!

As-tu essayé de stocker cette chaîne dans un std::u32string?

[Danny-k]

Il faudrait spécifier sous quel OS tu travailles, et quel est ton compilateur (pour savoir si tu supported au moins C++11 ou bien si tu es bloqué en C++98/03).

Si tu es sous un système Unix (Linux/Mac/Sun, etc.), il y a de grandes chances que la la locale par défaut soit en UTF8 (en fait hormis prédisposition particulière, c'est devenu le cas par défaut sur les systèmes POSIX), dans ce cas pas de soucis normalement, si ton string en entrée contient uniquement de l'ASCII ou bien de l'UTF8, tu n'as pas grand chose à faire.

Mais vu la question, je vais supposer que tu es sous Windows, et là c'est légèrement différent, Windows a fait le choix de s'orienter plutôt sur de l'UTF16 (quand il n'utilise pas des codepages), et c'est là qu'entre en jeu le type wchar_t, problème de ce type primitif c'est que c'est un type plutôt batârd, sous Windows il fait 2 octets (UTF16), sous Linux et autres, il fait plutôt 4 octets (UTF32).
Mais bon dans ce cas précis ce n'est pas spécialement gênant.

Tu as plusieurs solutions qui s'offre à toi, soit tu utilises la lib utf8-cpp qui est sous licence MIT (permissive), un exemple :

Code :

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

1
2
3
4
 
std::string str = "\xd8\xaa\xd8\xad\xd9\x8a\xd8\xa9"; //une chaine en UTF8
std::wstring wstr;
utf8::unchecked::utf8to16(str.begin(), str.end(), std::back_inserter(wstr));

Ou bien tu reprends juste ce qui t'intéresse de la lib (à tout cassé 4 petites fonctions).

Sinon en C++11 :

Code :

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

1
2
3
4
5
 
std::string str = "\xd8\xaa\xd8\xad\xd9\x8a\xd8\xa9"; //une chaine en UTF8
std::wstring wstr;
std::wstring_convert<std::codecvt_utf8<wchar_t>> iconv;
std::wstring wstr = iconv.from_bytes(str);

[foetus]

Déclaration:

Code :

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

unsigned char convert_UTF8_to_UTF16(unsigned char*, wchar_t**, unsigned short* /*utf16_len*/);

Définition:

Code :

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
unsigned char convert_UTF8_to_UTF16(unsigned char* str, wchar_t** utf16_str, unsigned short* output_utf16_len) {
	wchar_t* tmp_utf16_str;
 
	int code_point;
 
	unsigned short index, pos, utf8_len, utf16_len;
	unsigned char c, has_no_error;
 
	if ((str == NULL) || (utf16_str == NULL) || (*(utf16_str) != NULL) || (output_utf16_len == NULL)) { return 0; }
 
	has_no_error = 1;
 
	utf8_len  = 0;
 
	for (index = 0; (has_no_error && (index < 2)); ++index) {
		pos = 0;
 
		tmp_utf16_str = (*utf16_str);
		utf16_len = 0;
 
		c = str[pos];
 
		while(has_no_error && (c != '\0')) {
			if (c < 0x80){
				utf8_len = 1;
				++utf16_len;
 
				if (index == 1) {
					*tmp_utf16_str = (wchar_t) (c & 0xFF);
//					printf("%d (1)\n", (int) (*tmp_utf16_str));
 
					++tmp_utf16_str;
				}
			} else if ((c >> 5) == 0x6) {
				code_point = ((c & 0x1F) << 6);
 
				c = str[pos + 1];
 
				if (c != '\0') {
					utf8_len = 2;
					++utf16_len;
 
					if (index == 1) {
						*tmp_utf16_str = (wchar_t) ((code_point & 0x7FF) + (c & 0x3F));
//						printf("%d (2)\n", (int) (*tmp_utf16_str));
 
						++tmp_utf16_str;
					}
				} else {
					has_no_error = 0;
				}
			} else if ((c >> 4) == 0xE) {
				code_point = ((c & 0x0F) << 12);
 
				c = str[pos + 1];
 
				if (c != '\0') {
					code_point = ((code_point & 0xFFFF) + (((c & 0x3F) << 6) & 0xFFF));
 
					c = str[pos + 2];
 
					if (c != '\0') {
						utf8_len = 3;
						++utf16_len;
 
						if (index == 1) {
							*tmp_utf16_str = (wchar_t) ((code_point & 0xFFFF) + (c & 0x3F));
//							printf("%d (3)\n", (int) (*tmp_utf16_str));
 
							++tmp_utf16_str;
						}
					} else {
						has_no_error = 0;
					}
				} else {
					has_no_error = 0;
				}
			} else if ((c >> 3) == 0x1E) {
				code_point = ((c & 0x07) << 18);
 
				c = str[pos + 1];
 
				if (c != '\0') {
					code_point = ((code_point & 0x1FFFFF) + (((c & 0x3F) << 12) & 0x3FFFF));
 
					c = str[pos + 2];
 
					if (c != '\0') {
						code_point = ((code_point & 0x1FFFFF) + (((c & 0x3F) << 6) & 0xFFF));
 
						c = str[pos + 3];
 
						if (c != '\0') {
							code_point = ((code_point & 0x1FFFFF) + (c & 0x3F));
 
							utf8_len = 4;
							utf16_len += 2;
 
							if (index == 1) {
								*(tmp_utf16_str + 1) = (wchar_t) (0xDC00u + (code_point & 0x3FF));
 
								code_point = (code_point >> 10);
 
								if (((code_point >> 6) & 0x1F) > 0) {
									*tmp_utf16_str = (wchar_t) ((code_point - 0x40) + 0xD800u);
//									printf("%d (4.1)\n", (int) (*tmp_utf16_str));
								} else {
									*tmp_utf16_str = (wchar_t) (code_point + 0xD800u);
//									printf("%d (4.2)\n", (int) (*tmp_utf16_str));
								}
 
								tmp_utf16_str += 2;
							}
						} else {
							has_no_error = 0;
						}
					} else {
						has_no_error = 0;
					}
				} else {
					has_no_error = 0;
				}
			} else {
				has_no_error = 0;
			}
 
			if (has_no_error) {
				pos += utf8_len;
				c = str[pos];
			}
		}
 
		if (has_no_error) {
			if (index == 0) {
				if (utf16_len > 0) {
					++utf16_len;
					*(utf16_str) = (wchar_t*) malloc(utf16_len * sizeof(wchar_t));
				} else {
					has_no_error = 0;
				}
			} else /*if (index == 1)*/ {
				*tmp_utf16_str = L'\0';
			}
		}
	}
 
	if (has_no_error) {
		(*output_utf16_len) = utf16_len;
	} else {
		(*output_utf16_len) = 0;
	}
 
	return has_no_error;
}

[Médinoc]

Elle fait un peu peur, cette fonction: 150 lignes pour une fonction unique, et pas de const pour la supposée lecture...

Franchement, ce serait mieux de séparer les fonctionnalités: Une fonction pour lire un codepoint en UTF-8 en mémorisant la position dans le buffer d'entrée, une fonction pour l'écrire en UTF-16 dans un buffer de sortie, et une troisième fonction pour appeler les deux en boucle...