Discussion :

[corrector]

es ce réellement dépendant du codage unicode utilisé? et dans ce cas comment faire suivant le codage utilisé?
ou y as t'il une solution général?

Si ce tu n'as pas du NFC en entrée, ça va être plutôt coton, et la bibliothèque standard ne va pas marcher.

La solution générale, c'est une bibliothèque implémentant Unicode, mais je ne les connais pas précisément. Une telle bibliothèque va reconnaitre plein de jeux de caractères et faire les conversions dans tous les sens.

Pour les conversions, il y a iconv. Mais le non-NFC, voir ce message datant de : 18 Jan 2004! Je n'ai rien trouvé de plus récent.

[gb_68]

(Tu voulais dire NUL, je suppose.)

Oui je voulais parler du '\0'

Rappelons que le code est :

Code :

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

std::use_facet< std::ctype<wchar_t> >(loc).narrow(&ws[0], &ws[ws.length()], '?', &res[0]);

Où vois-tu "end()"?
Ou un même un itérateur "juste APRES le dernier élément" ("one-past-the-end")?

Je voulais dire que narrow utilise ses deux premiers paramètres "comme" deux iterateurs ( sauf que se sont forcément des pointeurs qui sont attendu la) et que de ce fait le second paramètre attendu doit être un pointeur sur "one-past-the-end". Mais c'est vrai que l'écriture &ws[ws.length()] .

Clause 23.3.4 [multiset] defines operator[] as data()[pos]

23.3.4 fait 4 pages! (je regarde n2315, là) Tu peux préciser?

Je me demandais juste ce qui était dit sur operator[] pour string. J'ai juste cité une partie de l'entrée

En pratique, et pour le futur, c'est garanti :
http://www.open-std.org/jtc1/sc22/wg...fects.html#530

en demande comment c'était défini pour les string.
Mais ce qui me dérange le plus c'est le &res[0] dans

Code :

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

std::use_facet< std::ctype<wchar_t> >(loc).narrow(&ws[0], &ws[ws.length()], '?', &res[0]);

on va tenter d'écrire dans la string à partir de son premier élément ; il n'y a pas que la continuité qui peut poser problème. Cela touche à l'implémentation même des string (si elle partage un même buffer, ... ). A mon avis il vaut mieux passer par un petit vector intermédiaire .
Un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
std::string narrow(const std::wstring& ws , std::locale loc = std::locale("") )
{
   std::vector<char> temp( ws.length() );
   std::use_facet< std::ctype<wchar_t> >(loc).narrow( ws.data() , ws.data()+ws.length(), '?', &temp[0]);
    return std::string(temp.begin(),temp.end());
}
 
std::wstring widen(const std::string& s, std::locale loc = std::locale(""))
{
    std::vector<wchar_t> temp( s.length() );
    std::use_facet< std::ctype<wchar_t> >(loc).widen( s.data() , s.data()+s.length(), &temp[0]);
    return std::wstring(temp.begin(),temp.end());
}

attention c'est juste une idée d'implémentation, non garantie

[yan]

Perso, je verais bien un truc comme ca :

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
// XXX : type d'encodage
struct widenToNarrow_XXX
{
char_t operator()(const wchar_t & c) 
{
//code de conversion pour un encodage donné
}
}
 
template <type converter>
std::string narrow(const std::wstring& ws  )
{
   std::vector<char> temp( ws.length() );
   std::transform(ws.begin(),ws.end(),temp.begin(),converter());
    return temp;
}
 
 
 
// XXX : type d'encodage
struct narrowToWiden_XXX
{
wchar_t operator()(const char_t & c) 
{
//code de conversion pour un encodage donné
}
}
 
template <type converter>
std::wstring widen(const std::string& s)
{
    std::vector<wchar_t> temp( s.length() );
     std::transform(s.begin(),s.end(),temp.begin(),converter());
    return temp;
}

[corrector]

Perso, je verais bien un truc comme ca :

Code :

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

1
2
3
4
5
6
template 
std::string narrow<type converter>(const std::wstring& ws  )
[...]
template
std::wstring widen<type converter>(const std::string& s)

Il manque quelque chose après template?

C'est voulu de se restreindre aux conversions 1 à 1?

[yan]

Il manque quelque chose après template?

je suis sur un projet C. J'ai ecrit vite

C'est voulu de se restreindre aux conversions 1 à 1?

Comment peut elle être autrement??

[corrector]

Comment peut elle être autrement??

Si tu produit un char pour chaque wchar_t, tu ne peux pas supporter Unicode.

Pourquoi poser à-priori une telle restriction?

[yan]

Si tu produit un char pour chaque wchar_t, tu ne peux pas supporter Unicode.

Pourquoi poser à-priori une telle restriction?

????
Tu veut dire dans le cas ou un char est encodé sur plusieurs wchar_t ?

[corrector]

????
Tu veut dire dans le cas ou un char est encodé sur plusieurs wchar_t ?

Oui.

[Médinoc]

Plutôt l'inverse, non (un wchar_t encodé sur plusieurs char) ?

[Médinoc]

Remarque, c'est aussi possible dans l'autre sens, si les wchar_t sont en UTF-16 (comme sous Windows)...

[yan]

Et comme cela?

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
// XXX : type d'encodage
struct widenToNarrow_XXX
{
widenToNarrow_XXX() : m_s("") {};
void operator()(const wchar_t & c) 
{
//code de conversion pour un encodage donné
//remplie m_s
}
std::string m_s;
}
 
template <type converter>
std::string narrow(const std::wstring& ws  )
{
    return std::for_each(s.begin(),s.end(),converter()).m_s;
}
 
 
 
// XXX : type d'encodage
struct narrowToWiden_XXX
{
narrowToWiden_XXX(): m_s(""){};
void operator()(const char_t & c) 
{
//code de conversion pour un encodage donné
//remplie m_s
}
std::wstring m_s;
}
 
template <type converter>
std::wstring widen(const std::string& s)
{
     return std::for_each(s.begin(),s.end(),converter()).m_s;
}

[corrector]

Plutôt l'inverse, non (un wchar_t encodé sur plusieurs char) ?

Si tu te restreint à une correspondance 1 à 1, tu élimines les deux cas!

Sérieusement, réponse : non.

Mais, comme je l'ai indiqué, dans le sens wchar_t -> char, quand plusieurs wchar_t représentent un seul char, voir l'exemple que j'ai donné dans mon premier message dans cette discussion (#5) :

encore faut-il être en forme NFC (ou NFKC...), c'est à dire qu'une lettre doit être décrite par un seul code-point, par exemple : "à" doit être codée LATIN SMALL LETTER A WITH GRAVE et non LATIN SMALL LETTER A suivit de COMBINING GRAVE ACCENT.

Est-ce qu'on veut qu'une wstring en NFD, qui donc représente 'à' comme {'LATIN SMALL LETTER A', 'COMBINING GRAVE ACCENT'} soit traduite en iso-latin-1 par 'à', où que la conversion produise "a?", '?' représentant l'échec de conversion?

[Médinoc]

Mongaulois:
Sympa, mais je vois plus un ostringstream qu'une string, sur le coup...

[corrector]

Remarque, c'est aussi possible dans l'autre sens, si les wchar_t sont en UTF-16 (comme sous Windows)...

Je ne pensais même pas à UTF-16, qui effectivement peut poser problème en général, mais pas forcément dans ce cas. Connais-tu des exemples de "surrogates pairs" qui se traduisent par un seul caractère dans un encodage mono-octet?

Je pensais au codage "idéal" des wchar_t en UCS-4, comme par exemple sous Linux.

[yan]

Mongaulois:
Sympa, mais je vois plus un ostringstream qu'une string, sur le coup...

Je ne sais pas trop comment se copie les ostringstream.
Mais peut être oui

[Médinoc]

OK, j'ai compris le coup des accents.
Quant aux surrogates pairs, disont que je ne connais aucun encodage mono-octet (ou variable 1-2) qui le fasse pour ne serait-ce qu'un caractère, mais je ne suis pas sur non plus qu'il n'en existe aucun, parmi tous les encodages qui existent (ou même en restreignant aux pages de codes supportées par Windows).

[yan]

En y réfléchissant.
Pourquoi une wstring pourrai encoder un caractère sur plusieurs wchar_t???
Pour fichier ok, mais pour une string. Je ne voie pas

[Médinoc]

Ben, justement pour les deux raisons qu'on vient de citer: Les accents, et le fait que les wchar_t sous Windows 2000 et supérieur* soient en UTF-16 ?

*Windows NT 4 ne supportait que l'UCS-2

[corrector]

En y réfléchissant.
Pourquoi une wstring pourrai encoder un caractère sur plusieurs wchar_t???

Et pourquoi pas?

Pour fichier ok, mais pour une string. Je ne voie pas

Qu'est-ce que tu ne vois pas? Si un fichier est codé ainsi, une chaine lue dans le fichier risque de l'être aussi.

[yan]

Ben, justement pour les deux raisons qu'on vient de citer: Les accents, et le fait que les wchar_t sous Windows 2000 et supérieur* soient en UTF-16 ?

un wchar_t en utf16??? c'est deux choses differentes, non??

Et pourquoi pas?
Qu'est-ce que tu ne vois pas? Si un fichier est codé ainsi, une chaine lue dans le fichier risque de l'être aussi.

les iterator de wstring n'auraient plus sens. Soit il represente un caractère, soit une partie du caractère!!!