Envoi de paquets de texte Unicode (win32) sur le réseau à l'aide de winsock?

Question

J'essaie d'envoyer des paquets de texte sur le réseau en utilisant winsock. Cependant le texte est stocké comme wchar_t et je dois pouvoir convertir le texte en format byte (char) pour l'envoi sur le réseau, qui sera alors converti en wchar_t.

J'ai expérimenté l'utilisation de ostringstream et j'ai converti la chaîne wchar_t de la mienne en un format qui ressemble à un byte, mais quand j'essaye de faire marche arrière, je reçois un tas de charabia.

Je n'arrive pas à trouver de réponses lorsque vous cherchez en ligne, donc toute aide serait grandement appréciée.

OK, voici un code avec lequel j'ai joué.

std::wstring text(ieS("Hello")); 
std::ostringstream ostr; 
ostr.imbue(std::locale()); 
ostr << text.c_str(); 
std::string text2 = ostr.str(); 

Convertir en std :: string pour obtenir le format char.

std::wostringstream wostr; 
wostr.imbue(std::locale()); 
wostr << text2.c_str(); 
text = oss.str(); // gibberish 

reconvertir à std :: wstring pour obtenir le format wchar_t ...

Answer 1

Vos amis sont ici:

WideCharToMultiByte, en passant la page de codes pour UTF-8 en tant que page de code MB.

MultiByteToWideChar, idem.

Answer 2

Exemple réaffiché de here:

#include <locale> 
#include <iostream> 
#include <string> 
#include <sstream> 
using namespace std ; 

wstring widen(const string& str) 
{ 
    wostringstream wstm ; 
    const ctype<wchar_t>& ctfacet = 
         use_facet< ctype<wchar_t> >(wstm.getloc()) ; 
    for(size_t i=0 ; i<str.size() ; ++i) 
       wstm << ctfacet.widen(str[i]) ; 
    return wstm.str() ; 
} 

string narrow(const wstring& str) 
{ 
    ostringstream stm ; 
    const ctype<char>& ctfacet = 
         use_facet< ctype<char> >(stm.getloc()) ; 
    for(size_t i=0 ; i<str.size() ; ++i) 
        stm << ctfacet.narrow(str[i], 0) ; 
    return stm.str() ; 
} 

int main() 
{ 
    { 
    const char* cstr = "abcdefghijkl" ; 
    const wchar_t* wcstr = widen(cstr).c_str() ; 
    wcout << wcstr << L'\n' ; 
    } 
    { 
    const wchar_t* wcstr = L"mnopqrstuvwx" ; 
    const char* cstr = narrow(wcstr).c_str() ; 
    cout << cstr << '\n' ; 
    } 
}