C ++ Convertit une chaîne (ou char *) en wstring (ou wchar_t *)

string s = "おはよう";
wstring ws = FUNCTION(s, ws);

Comment attribuer le contenu de s à ws?

Recherche Google et utilisation de certaines techniques, mais ils ne peuvent pas attribuer le contenu exact. Le contenu est déformé.

En supposant que la chaîne d'entrée dans votre exemple (お は よ う) est une représentation encodée en UTF-8 (ce qui n'est pas le cas, à première vue, mais supposons que ce soit pour cette explication :-)) représentation d'une chaîne Unicode de votre intérêt, alors votre problème peut être entièrement résolu avec la bibliothèque standard (C ++ 11 et plus récent) seule.

La version TL; DR:

#include <locale>
#include <codecvt>
#include <string>

std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
std::string narrow = converter.to_bytes(wide_utf16_source_string);
std::wstring wide = converter.from_bytes(narrow_utf8_source_string);

Exemple plus long compilable et exécutable en ligne:

(Ils montrent tous le même exemple. Il y en a juste beaucoup pour la redondance ...)

• http://ideone.com/KA1oty
• http://ide.geeksforgeeks.org/5pRLSh
• http://rextester.com/DIJZK52174

Remarque (ancienne) :

Comme indiqué dans les commentaires et expliqué dans https://stackoverflow.com/a/17106065/6345, il existe des cas où l'utilisation de la bibliothèque standard pour convertir entre UTF-8 et UTF-16 peut donner des différences inattendues dans les résultats sur différentes plates-formes . Pour une meilleure conversion, considérez std::codecvt_utf8comme décrit sur http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Remarque (nouveau) :

Étant donné que l'en- codecvttête est obsolète en C ++ 17, certaines inquiétudes concernant la solution présentée dans cette réponse ont été soulevées. Cependant, le comité des normes C ++ a ajouté une déclaration importante dans http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html disant

ce composant de bibliothèque devrait être retiré à l'annexe D, parallèlement, jusqu'à ce qu'un remplacement approprié soit normalisé.

Donc, dans un avenir prévisible, la codecvtsolution de cette réponse est sûre et portable.

int StringToWString(std::wstring &ws, const std::string &s)
{
    std::wstring wsTmp(s.begin(), s.end());

    ws = wsTmp;

    return 0;
}

Votre question est sous-spécifiée. Strictement, cet exemple est une erreur de syntaxe. Cependant, std::mbstowcsc'est probablement ce que vous recherchez.

C'est une fonction de bibliothèque C et fonctionne sur des tampons, mais voici un idiome facile à utiliser, gracieuseté de TBohne (anciennement Mooing Duck):

std::wstring ws(s.size(), L' '); // Overestimate number of code points.
ws.resize(std::mbstowcs(&ws[0], s.c_str(), s.size())); // Shrink to fit.

API Windows uniquement, implémentation antérieure à C ++ 11, au cas où quelqu'un en aurait besoin:

#include <stdexcept>
#include <vector>
#include <windows.h>

using std::runtime_error;
using std::string;
using std::vector;
using std::wstring;

wstring utf8toUtf16(const string & str)
{
   if (str.empty())
      return wstring();

   size_t charsNeeded = ::MultiByteToWideChar(CP_UTF8, 0, 
      str.data(), (int)str.size(), NULL, 0);
   if (charsNeeded == 0)
      throw runtime_error("Failed converting UTF-8 string to UTF-16");

   vector<wchar_t> buffer(charsNeeded);
   int charsConverted = ::MultiByteToWideChar(CP_UTF8, 0, 
      str.data(), (int)str.size(), &buffer[0], buffer.size());
   if (charsConverted == 0)
      throw runtime_error("Failed converting UTF-8 string to UTF-16");

   return wstring(&buffer[0], charsConverted);
}

Si vous utilisez Windows / Visual Studio et devez convertir une chaîne en wstring, vous pouvez utiliser:

#include <AtlBase.h>
#include <atlconv.h>
...
string s = "some string";
CA2W ca2w(s.c_str());
wstring w = ca2w;
printf("%s = %ls", s.c_str(), w.c_str());

Même procédure pour convertir une chaîne wstring en chaîne (parfois vous devrez spécifier une page de code ):

#include <AtlBase.h>
#include <atlconv.h>
...
wstring w = L"some wstring";
CW2A cw2a(w.c_str());
string s = cw2a;
printf("%s = %ls", s.c_str(), w.c_str());

Vous pouvez spécifier une page de code et même UTF8 (c'est assez agréable lorsque vous travaillez avec JNI / Java ). Un moyen standard de convertir un std :: wstring en utf8 std :: string est montré dans cette réponse .

// 
// using ATL
CA2W ca2w(str, CP_UTF8);

// 
// or the standard way taken from the answer above
#include <codecvt>
#include <string>

// convert UTF-8 string to wstring
std::wstring utf8_to_wstring (const std::string& str) {
    std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
    return myconv.from_bytes(str);
}

// convert wstring to UTF-8 string
std::string wstring_to_utf8 (const std::wstring& str) {
    std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
    return myconv.to_bytes(str);
}

Si vous voulez en savoir plus sur les pages de codes, il y a un article intéressant sur Joel sur le logiciel: le minimum absolu que chaque développeur de logiciel doit absolument, positivement savoir sur Unicode et les jeux de caractères .

Ces macros CA2W (Convert Ansi to Wide = unicode) font partie des macros de conversion de chaîne ATL et MFC , exemples inclus.

Parfois, vous devrez désactiver l'avertissement de sécurité # 4995 ', je ne connais pas d'autre solution de contournement (pour moi, cela se produit lorsque j'ai compilé pour WindowsXp dans VS2012).

#pragma warning(push)
#pragma warning(disable: 4995)
#include <AtlBase.h>
#include <atlconv.h>
#pragma warning(pop)

Edit: Eh bien, selon cet article, l'article de Joel semble être: "tout en étant divertissant, il est assez léger sur les détails techniques réels". Article: Ce que tout programmeur doit absolument savoir sur le codage et les jeux de caractères pour travailler avec du texte .

Voici un moyen de combiner string, wstringet les constantes de chaîne mixtes à wstring. Utilisez la wstringstreamclasse.

Cela ne fonctionne PAS pour les encodages de caractères multi-octets. C'est juste une manière stupide de jeter la sécurité de type et d'étendre les caractères 7 bits de std :: string dans les 7 bits inférieurs de chaque caractère de std: wstring. Cela n'est utile que si vous avez des chaînes ASCII 7 bits et que vous devez appeler une API qui nécessite des chaînes larges.

#include <sstream>

std::string narrow = "narrow";
std::wstring wide = L"wide";

std::wstringstream cls;
cls << " abc " << narrow.c_str() << L" def " << wide.c_str();
std::wstring total= cls.str();

Du char*au wstring:

char* str = "hello worlddd";
wstring wstr (str, str+strlen(str));

Du stringau wstring:

string str = "hello worlddd";
wstring wstr (str.begin(), str.end());

Notez que cela ne fonctionne bien que si la chaîne en cours de conversion ne contient que des caractères ASCII.

en utilisant Boost.Locale:

ws = boost::locale::conv::utf_to_utf<wchar_t>(s);

Cette variante est ma préférée dans la vraie vie. Il convertit l'entrée, si elle est valide UTF-8, en la valeur respective wstring. Si l'entrée est corrompue, le wstringest construit à partir des octets uniques. Ceci est extrêmement utile si vous ne pouvez pas vraiment être sûr de la qualité de vos données d'entrée.

std::wstring convert(const std::string& input)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        return converter.from_bytes(input);
    }
    catch(std::range_error& e)
    {
        size_t length = input.length();
        std::wstring result;
        result.reserve(length);
        for(size_t i = 0; i < length; i++)
        {
            result.push_back(input[i] & 0xFF);
        }
        return result;
    }
}

Si vous avez QT et si vous êtes paresseux pour implémenter une fonction et des choses que vous pouvez utiliser

std :: string str; QString (chaîne) .toStdWString ()

La méthode s2ws fonctionne bien. L'espoir aide.

std::wstring s2ws(const std::string& s) {
    std::string curLocale = setlocale(LC_ALL, ""); 
    const char* _Source = s.c_str();
    size_t _Dsize = mbstowcs(NULL, _Source, 0) + 1;
    wchar_t *_Dest = new wchar_t[_Dsize];
    wmemset(_Dest, 0, _Dsize);
    mbstowcs(_Dest,_Source,_Dsize);
    std::wstring result = _Dest;
    delete []_Dest;
    setlocale(LC_ALL, curLocale.c_str());
    return result;
}

Sur la base de mes propres tests (sur Windows 8, vs2010), les mbstowcs peuvent en fait endommager la chaîne d'origine, cela ne fonctionne qu'avec la page de codes ANSI. Si MultiByteToWideChar / WideCharToMultiByte peut également provoquer une corruption de chaîne - mais ils ont tendance à remplacer les caractères qu'ils ne connaissent pas par '?' points d'interrogation, mais mbstowcs a tendance à s'arrêter lorsqu'il rencontre un caractère inconnu et coupe une chaîne à ce point précis. (J'ai testé des caractères vietnamiens sur des fenêtres finlandaises).

Préférez donc la fonction API Multi * -windows aux fonctions analogiques ansi C.

De plus, ce que j'ai remarqué, le moyen le plus court d'encoder une chaîne d'une page de code à une autre n'est pas d'utiliser les appels de fonction api MultiByteToWideChar / WideCharToMultiByte, mais leurs macros ATL analogiques: W2A / A2W.

Donc, la fonction analogique mentionnée ci-dessus ressemblerait à:

wstring utf8toUtf16(const string & str)
{
   USES_CONVERSION;
   _acp = CP_UTF8;
   return A2W( str.c_str() );
}

_acp est déclaré dans la macro USES_CONVERSION.

Ou aussi fonction qui me manque souvent lors de la conversion d'anciennes données en nouvelles:

string ansi2utf8( const string& s )
{
   USES_CONVERSION;
   _acp = CP_ACP;
   wchar_t* pw = A2W( s.c_str() );

   _acp = CP_UTF8;
   return W2A( pw );
}

Mais veuillez noter que ces macros utilisent fortement la pile - ne pas utiliser pour les boucles ou les boucles récursives pour la même fonction - après avoir utilisé la macro W2A ou A2W - mieux vaut retourner ASAP, donc la pile sera libérée de la conversion temporaire.

Chaîne en wstring

std::wstring Str2Wstr(const std::string& str)
{
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}

wstring en chaîne

std::string Wstr2Str(const std::wstring& wstr)
{
    typedef std::codecvt_utf8<wchar_t> convert_typeX;
    std::wstring_convert<convert_typeX, wchar_t> converterX;
    return converterX.to_bytes(wstr);
}

string s = "おはよう"; est une erreur.

Vous devez utiliser wstring directement:

wstring ws = L"おはよう";

utilisez ce code pour convertir votre chaîne en wstring

std::wstring string2wString(const std::string& s){
    int len;
    int slength = (int)s.length() + 1;
    len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0); 
    wchar_t* buf = new wchar_t[len];
    MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
    std::wstring r(buf);
    delete[] buf;
    return r;
}

int main(){
    std::wstring str="your string";
    std::wstring wStr=string2wString(str);
    return 0;
}