C ++ Converter string (ou char *) em wstring (ou wchar_t *)

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

Como eu atribuiria o conteúdo de s a ws?

Pesquisou no Google e usou algumas técnicas, mas elas não podem atribuir o conteúdo exato. O conteúdo está distorcido.

Supondo que a string de entrada no seu exemplo (お は よ う) seja codificada em UTF-8 (o que não é, pelo que parece, mas vamos assumir que seja por causa desta explicação :-)) de uma string Unicode de seu interesse, seu problema poderá ser totalmente resolvido apenas com a biblioteca padrão (C ++ 11 e mais recente).

A versão 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);

Exemplo compilável e executável online mais longo:

(Todos mostram o mesmo exemplo. Existem muitos para redundância ...)

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

Nota (antiga) :

Conforme apontado nos comentários e explicado em https://stackoverflow.com/a/17106065/6345, há casos em que o uso da biblioteca padrão para converter entre UTF-8 e UTF-16 pode gerar diferenças inesperadas nos resultados em diferentes plataformas . Para uma melhor conversão, considere std::codecvt_utf8o descrito em http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Nota (nova) :

Como o codecvtcabeçalho foi descontinuado no C ++ 17, foram levantadas algumas preocupações com a solução apresentada nesta resposta. No entanto, o comitê de padrões do C ++ adicionou uma declaração importante em http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html dizendo

esse componente da biblioteca deve ser retirado do anexo D, ao lado, até que uma substituição adequada seja padronizada.

Portanto, no futuro próximo, a codecvtsolução nesta resposta é segura e portátil.

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

    ws = wsTmp;

    return 0;
}

Sua pergunta está subespecificada. Estritamente, esse exemplo é um erro de sintaxe. No entanto, std::mbstowcsé provavelmente o que você está procurando.

É uma função da biblioteca C e opera em buffers, mas aqui está um idioma fácil de usar, cortesia de TBohne (anteriormente 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.

Somente API do Windows, antes da implementação do C ++ 11, caso alguém precise:

#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 você estiver usando o Windows / Visual Studio e precisar converter uma string em wstring, poderá usar:

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

O mesmo procedimento para converter uma string para string (às vezes você precisará especificar uma página de código ):

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

Você pode especificar uma página de código e até UTF8 (isso é muito bom ao trabalhar com JNI / Java ). Uma maneira padrão de converter um std :: wstring em utf8 std :: string é mostrada nesta resposta .

// 
// 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 você quiser saber mais sobre páginas de código, há um artigo interessante sobre Joel no Software: O Mínimo Absoluto Todo desenvolvedor de software deve saber absolutamente, positivamente, positivamente sobre Unicode e conjuntos de caracteres .

Essas macros CA2W (Converter ANSI para Wide = unicode) fazem parte das macros de conversão de string ATL e MFC , incluindo exemplos.

Às vezes, você precisará desativar o aviso de segurança # 4995 ', não conheço outra solução alternativa (isso acontece quando eu compilei o WindowsXp no VS2012).

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

Edit: Bem, de acordo com este artigo, o artigo de Joel parece ser: "embora divertido, é bastante claro sobre detalhes técnicos reais". Artigo: O que todo programador precisa absolutamente e positivamente de saber sobre codificação e conjuntos de caracteres para trabalhar com texto .

Aqui está uma maneira de combinar string, wstringe constantes de cadeia mista para wstring. Use a wstringstreamclasse.

Isso NÃO funciona para codificações de caracteres de vários bytes. Esta é apenas uma maneira idiota de jogar fora a segurança de tipo e expandir os caracteres de 7 bits do std :: string para os 7 bits inferiores de cada caractere do std: wstring. Isso só é útil se você tiver uma sequência ASCII de 7 bits e precisar chamar uma API que exija uma sequência ampla.

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

De char*para wstring:

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

De stringpara wstring:

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

Observe que isso só funciona bem se a sequência que está sendo convertida contiver apenas caracteres ASCII.

usando Boost.Locale:

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

Essa variante é a minha favorita na vida real. Ele converte a entrada, se for UTF-8 válido , na respectiva wstring. Se a entrada estiver corrompida, ela wstringserá construída a partir dos bytes únicos. Isso é extremamente útil se você realmente não tiver certeza da qualidade dos seus dados de entrada.

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 você tem QT e tem preguiça de implementar uma função e outras coisas, pode usar

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

O método s2ws funciona bem. A esperança ajuda.

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

Com base nos meus próprios testes (no Windows 8, vs2010), o mbstowcs pode danificar a string original, funciona apenas com a página de código ANSI. Se MultiByteToWideChar / WideCharToMultiByte também puder causar corrupção de string - mas eles tendem a substituir caracteres que não conhecem por '?' pontos de interrogação, mas o mbstowcs tende a parar quando encontra caracteres desconhecidos e corta a corda nesse exato momento. (Eu testei caracteres vietnamitas em janelas finlandesas).

Portanto, prefira a função api da Multi-windows em vez das funções analógicas ansi C.

Além disso, o que eu notei que a maneira mais curta de codificar string de uma página de código para outra não é usar as funções de API api da MultiByteToWideChar / WideCharToMultiByte, mas suas macros analógicas ATL: W2A / A2W.

Portanto, a função analógica, como mencionado acima, soa como:

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

_acp é declarado na macro USES_CONVERSION.

Ou também a função que frequentemente sinto falta ao realizar a conversão de dados antigos para um novo:

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

   _acp = CP_UTF8;
   return W2A( pw );
}

Mas observe que essas macro usam muito a pilha - não use para loops ou loops recursivos para a mesma função - depois de usar a macro W2A ou A2W - é melhor retornar o mais rápido possível, para que a pilha seja liberada da conversão temporária.

String para 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 para 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 = "おはよう"; é um erro.

Você deve usar o wstring diretamente:

wstring ws = L"おはよう";

use esse código para converter sua string em 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;
}