Discussion :

[maitrelame2]

Bonjour,

Je recherche actuellement comment envoyer un wchar_t* avec la fonction send en TCP/IP pour envoye des accents au client.

Voici le code qui permet de mettre mes wchar_t* dans le mon buffer.
m_byte etant une string.

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
void  CByte::addChar(char* B, size_t t)
{
    for(unsigned int i=0;i<=t;i++)
        m_byte.push_back(B[i]);
 
}
char* CByte::GetByte()
{
    char* buffer = new char[m_byte.size()+1];
    for(unsigned int i=0;i<= m_byte.size();i++)
        buffer[i] = m_byte[i];
    return buffer;
}
 
template <class T> CByte& operator<<(const T& add)
{
         std::ostringstream Stream;
         Stream << add;
         addChar((char*)Stream.str().c_str(), Stream.str().size());
         return *this;
}

J'utilise le code suivant :

Code :

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

1
2
3
4
 
CByte buffer;
wchar_t wstr[] = L"arb==";
buffer << wstr;

Quand je regarde le contenu du buffer en hexa j'obtiens ceci :
0x30 0x78 0x63 0x61 0x63 0x66 0x65 0x35 0x38 0x0
Mais comment puis-je obtenir ma chaine wchar_t a partir de la chaine de char retourne par la fonction GetByte() ?

PS : Je ne veux pas convertir mais transformer ma chaine wchar_t en groupe de byte pour l'envoyer sur reseau puis retourner sur 2 byte une fois le groupe de byte recu.

Merci.

[loufoque]

wchar_t n'ayant pas une représentation binaire standard, l'envoyer par TCP tel quel n'a aucun sens.
Envoie de l'UTF-16, de l'UTF-16BE, de l'UTF-16LE, de l'UTF-32, de l'UTF-32LE, de l'UTF-32BE, de l'UCS-2, de l'UCS-2BE, de l'UCS-2LE ou quoi que ce soit d'autre, mais fais ton choix.

[maitrelame2]

Mais a ce moment la comment puis-je choisir le type d'encodage que je veux...
De plus mon probleme n'est toujours pas resolu...
Je ne vois toujours pas comment envoyer des accents sur le reseau dans utiliser le type wchar_t...

[Laurent Gomila]

wchar_t ce n'est qu'un type qui n'a pas une taille fixe, et qui ne donne aucune indication sur l'encodage utilisé.

Utiliser un vrai type unicode (cf. la liste de loufoque) te donnerait ces deux choses : un encodage précis, et une taille connue quelque soit la plateforme.

Pour du texte européen et anglais, l'UTF-8 sera le plus économique en terme d'occupation mémoire. En plus il ne te posera pas de problème d'endianess.

[wiztricks]

wchar_t n'ayant pas une représentation binaire standard, l'envoyer par TCP tel quel n'a aucun sens.

Je trouve que vous êtes un peu dur!
Le fait est que la taille d'un wchar_t dépend de l'implémentation est peut varier de 1, 2 a 4 octets suivant le compilo ou la plateforme.

=> si vous voulez transférer des caractères UNICODE, il va donc falloir s'entendre côté police choisie et aussi sur "l'endianess" du codage.

Cela étant précisé, on pourra transformer une chaîne de caractères UNICODE en une suite d'octets pour la transférer et la lire sur le réseau.
- W

[maitrelame2]

J'utilise le moteur 3D irrlicht, je suppose que j'utilise le meme encodage que le moteur.
Je crois que l'encodage est sur 16 bits.
Mais je ne vois toujours pas comment recupere en wchar_t le packet recu en char*...
Sinon pour l'UFT8 comment puis-je l'utiliser ?

PS : Il se peut que j'ai a traduire le jeu en japonais a l'avenir. A la base il sera en anglais si je fais ca maintenant c'est pour ne pas avoir a revenir dessus quand le jeu sera finit...

EDIT : Je viens de trouver http://www.unix.com/high-level-progr...-8-back-c.html
Est-ce que cette solution serait la bonne dans mon cas.
Dans ce cas l'envoie via le reseau fonctionnerait correctement via un cast de char* ?

[loufoque]

Même si tu supposes que wchar_t est toujours 2 octets et 16 bits (ce qui n'est nullement le cas), tu as encore UTF-16(rien/LE/BE) et UCS-2(rien/LE/BE).

La différence entre UCS-2 et UTF-16 c'est que UTF-16 gère tout Unicode grâce aux surrogate pairs, alors que UCS-2 ne gère que 2^16 caractères.
La différence entre LE et BE c'est l'endianness. LE c'est Little-Endian, BE c'est Big-Endian. Une machine de type Intel x86 fonctionnera en mémoire en LE, mais une machine de type PowerPC fonctionnera en mémoire en BE. D'autres machines plus exotiques auront quelque chose qui n'est ni l'un ni l'autre (enfin, pour des mots de 2 octets, ça devrait pas poser de problèmes...) Tu ne peux donc pas te contenter de lire la mémoire telle-quelle sur le réseau, il faut choisir un format unique et bien défini.
Ensuite, UTF-16 et UCS-2 "tout court" utilisent le premier mot pour indiquer s'il s'agit de LE ou de BE, ce qui peut faciliter l'écriture des données.