C ++ Converti stringa (o char *) in wstring (o wchar_t *)

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

Come assegnerei il contenuto di s a ws?

Hanno cercato su Google e utilizzato alcune tecniche ma non possono assegnare il contenuto esatto. Il contenuto è distorto.

Supponendo che la stringa di input nel tuo esempio (お は よ う) sia una codifica UTF-8 (che non è, a quanto pare, ma supponiamo che sia per il bene di questa spiegazione :-)) rappresentazione di una stringa Unicode di tuo interesse, quindi il tuo problema può essere risolto completamente con la sola libreria standard (C ++ 11 e successive).

La versione 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);

Esempio compilabile e eseguibile online più lungo:

(Tutti mostrano lo stesso esempio. Ce ne sono solo molti per la ridondanza ...)

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

Nota (vecchia) :

Come sottolineato nei commenti e spiegato in https://stackoverflow.com/a/17106065/6345 ci sono casi in cui l'uso della libreria standard per la conversione tra UTF-8 e UTF-16 potrebbe dare differenze inaspettate nei risultati su piattaforme diverse . Per una migliore conversione, considerare std::codecvt_utf8come descritto su http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Nota (nuova) :

Poiché l' codecvtintestazione è obsoleta in C ++ 17, sono state sollevate alcune preoccupazioni in merito alla soluzione presentata in questa risposta. Tuttavia, il comitato per gli standard C ++ ha aggiunto una dichiarazione importante in http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html dicendo

questo componente della biblioteca dovrebbe essere ritirato all'allegato D, a fianco, fino a quando non viene standardizzata una sostituzione adeguata.

Quindi, nel prossimo futuro, la codecvtsoluzione in questa risposta è sicura e portatile.

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

    ws = wsTmp;

    return 0;
}

La tua domanda non è specificata In senso stretto, questo esempio è un errore di sintassi. Tuttavia, std::mbstowcsè probabilmente quello che stai cercando.

È una funzione C-library e opera su buffer, ma ecco un linguaggio facile da usare, per gentile concessione di TBohne (precedentemente 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.

Solo API Windows, implementazione pre C ++ 11, nel caso qualcuno ne abbia bisogno:

#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);
}

Se stai usando Windows / Visual Studio e devi convertire una stringa in wstring puoi usare:

#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());

Stessa procedura per convertire una stringa in stringa (a volte è necessario specificare una tabella codici ):

#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());

È possibile specificare una tabella codici e persino UTF8 (che è piuttosto carino quando si lavora con JNI / Java ). In questa risposta viene mostrato un modo standard per convertire una stringa std :: wstring in utf8 std :: stringa .

// 
// 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);
}

Se vuoi saperne di più sui codici, c'è un interessante articolo su Joel on Software: il minimo assoluto che ogni sviluppatore di software deve assolutamente conoscere positivamente su Unicode e set di caratteri .

Queste macro CA2W (Converti Ansi in Wide = unicode) fanno parte delle macro di conversione stringhe ATL e MFC , inclusi gli esempi.

A volte dovrai disabilitare l'avviso di sicurezza # 4995 ', non conosco altre soluzioni alternative (a me succede quando ho compilato per WindowsXp in VS2012).

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

Modifica: Beh, secondo questo articolo l'articolo di Joel sembra essere: "mentre è divertente, è abbastanza leggero sui dettagli tecnici reali". Articolo: Ciò che ogni programmatore deve assolutamente e positivamente sapere sulla codifica e sui set di caratteri per lavorare con il testo .

Ecco un modo di combinare string, wstringe costanti stringa misti a wstring. Usa la wstringstreamclasse.

Questo NON funziona per le codifiche di caratteri multi-byte. Questo è solo un modo stupido di gettare via la sicurezza del tipo ed espandere i caratteri a 7 bit da std :: string nei 7 bit inferiori di ogni carattere di std: wstring. Ciò è utile solo se si dispone di stringhe ASCII a 7 bit e è necessario chiamare un'API che richiede stringhe estese.

#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();

Da char*a wstring:

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

Da stringa wstring:

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

Nota che funziona bene solo se la stringa da convertire contiene solo caratteri ASCII.

utilizzando Boost.Locale:

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

Questa variante è la mia preferita nella vita reale. Converte l'ingresso, se è UTF-8 valido , nel rispettivo wstring. Se l'input è danneggiato, wstringviene costruito dai singoli byte. Questo è estremamente utile se non puoi davvero essere sicuro della qualità dei tuoi dati di input.

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;
    }
}

Se hai QT e se sei pigro per implementare una funzione e cose che puoi usare

std :: string str; QString (str) .toStdWString ()

il metodo s2ws funziona bene. La speranza aiuta.

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;
}

Basato sul mio test (su Windows 8, vs2010) mbstowcs può effettivamente danneggiare la stringa originale, funziona solo con la tabella codici ANSI. Se MultiByteToWideChar / WideCharToMultiByte può anche causare il danneggiamento delle stringhe, ma tendono a sostituire i caratteri che non conoscono con "?" punti interrogativi, ma mbstowcs tende a fermarsi quando incontra un carattere sconosciuto e taglia la stringa proprio in quel punto. (Ho testato personaggi vietnamiti su finestre finlandesi).

Quindi preferisci la funzione API * Multi-windows rispetto alle funzioni analogiche C.

Inoltre, ciò che ho notato il modo più breve per codificare la stringa da una tabella codici a un'altra non è usare le chiamate della funzione API MultiByteToWideChar / WideCharToMultiByte ma i loro macro ATL analogici: W2A / A2W.

Quindi la funzione analogica sopra menzionata suona come:

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

_acp è dichiarato nella macro USES_CONVERSION.

O anche la funzione che spesso mi manca quando eseguo la conversione di dati vecchi in uno nuovo:

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

   _acp = CP_UTF8;
   return W2A( pw );
}

Ma tieni presente che quelle macro usano pesantemente lo stack - non utilizzare per loop o loop ricorsivi per la stessa funzione - dopo aver usato macro W2A o A2W - meglio per restituire al più presto, quindi lo stack verrà liberato dalla conversione temporanea.

Stringa a filo

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 a String

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 = "おはよう"; è un errore.

Dovresti usare direttamente wstring:

wstring ws = L"おはよう";

usa questo codice per convertire la stringa in 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;
}