C ++ Convertir cadena (o char *) a wstring (o wchar_t *)

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

¿Cómo asignaría el contenido de s a ws?

Busqué en Google y usé algunas técnicas, pero no pueden asignar el contenido exacto. El contenido está distorsionado.

Suponiendo que la cadena de entrada en su ejemplo (お は よ う) es una codificación UTF-8 (que no lo es, por lo que parece, pero supongamos que es por el bien de esta explicación :-)) representación de una cadena Unicode de su interés, entonces su problema puede resolverse completamente con la biblioteca estándar (C ++ 11 y más reciente) solo.

La versión 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);

Ejemplo compilable y ejecutable en línea más largo:

(Todos muestran el mismo ejemplo. Hay muchos para la redundancia ...)

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

Nota (antigua) :

Como se señaló en los comentarios y se explicó en https://stackoverflow.com/a/17106065/6345, hay casos en que el uso de la biblioteca estándar para convertir entre UTF-8 y UTF-16 podría dar diferencias inesperadas en los resultados en diferentes plataformas . Para una mejor conversión, considere std::codecvt_utf8como se describe en http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Nota (nueva) :

Dado que el codecvtencabezado está en desuso en C ++ 17, surgieron algunas preocupaciones sobre la solución presentada en esta respuesta. Sin embargo, el comité de estándares de C ++ agregó una declaración importante en http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html diciendo

este componente de la biblioteca debe retirarse del Anexo D, junto a él, hasta que se estandarice un reemplazo adecuado.

Entonces, en el futuro previsible, la codecvtsolución en esta respuesta es segura y portátil.

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

    ws = wsTmp;

    return 0;
}

Su pregunta no está especificada. Estrictamente, ese ejemplo es un error de sintaxis. Sin embargo, std::mbstowcses probablemente lo que estás buscando.

Es una función de biblioteca C y funciona en buffers, pero aquí hay un modismo fácil de usar, cortesía 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.

Solo API de Windows, implementación previa a C ++ 11, en caso de que alguien lo necesite:

#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 está utilizando Windows / Visual Studio y necesita convertir una cadena a wstring, puede 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());

El mismo procedimiento para convertir un wstring a cadena (a veces necesitará especificar una página de códigos ):

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

Puede especificar una página de códigos e incluso UTF8 (eso es bastante bueno cuando se trabaja con JNI / Java ). En esta respuesta se muestra una forma estándar de convertir un std :: wstring a utf8 std :: string .

// 
// 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 desea saber más acerca de las páginas de códigos, hay un artículo interesante sobre Joel sobre software: el mínimo absoluto que todo desarrollador de software debe saber absolutamente, positivamente sobre Unicode y los conjuntos de caracteres .

Estas macros CA2W (Convertir Ansi a Wide = unicode) son parte de las macros de conversión de cadenas ATL y MFC , incluidos los ejemplos.

A veces necesitará deshabilitar la advertencia de seguridad # 4995 ', no sé de otra solución (para mí sucede cuando compilé para Windows XP en VS2012).

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

Editar: Bueno, de acuerdo con este artículo, el artículo de Joel parece ser: "aunque entretenido, es bastante ligero en detalles técnicos reales". Artículo: Lo que todo programador absolutamente necesita saber sobre la codificación y los juegos de caracteres para trabajar con texto .

Aquí hay una forma de combinar string, wstringy constantes de cadena mixtas para wstring. Usa la wstringstreamclase.

Esto NO funciona para codificaciones de caracteres de varios bytes. Esta es solo una manera tonta de desechar la seguridad de tipos y expandir caracteres de 7 bits desde std :: string a los 7 bits inferiores de cada carácter de std: wstring. Esto solo es útil si tiene cadenas ASCII de 7 bits y necesita llamar a una API que requiere cadenas anchas.

#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*a wstring:

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

De stringa wstring:

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

Tenga en cuenta que esto solo funciona bien si la cadena que se convierte contiene solo caracteres ASCII.

usando Boost.Locale:

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

Esta variante es mi favorita en la vida real. Convierte la entrada, si es válida UTF-8, a la respectiva wstring. Si la entrada está dañada, wstringse construye a partir de los bytes individuales. Esto es extremadamente útil si realmente no puede estar seguro de la calidad de sus datos 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;
    }
}

Si tienes QT y eres flojo para implementar una función y otras cosas, puedes usar

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

El método s2ws funciona bien. La esperanza ayuda.

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

Según mis propias pruebas (en Windows 8, vs2010), mbstowcs puede dañar la cadena original, solo funciona con la página de códigos ANSI. Si MultiByteToWideChar / WideCharToMultiByte también puede causar daños en la cadena, pero tienden a reemplazar los caracteres que no conocen con '?' los signos de interrogación, pero mbstowcs tiende a detenerse cuando encuentra caracteres desconocidos y corta cadenas en ese mismo punto. (He probado caracteres vietnamitas en ventanas finlandesas).

Por lo tanto, prefiera la función Multi * -windows api sobre las funciones analógicas ansi C.

Además, lo que he notado de la manera más corta para codificar cadenas de una página de códigos a otra no es usar llamadas de función api MultiByteToWideChar / WideCharToMultiByte sino sus macros analógicas ATL: W2A / A2W.

Entonces, la función analógica como se mencionó anteriormente sonaría así:

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

_acp se declara en la macro USES_CONVERSION.

O también la función que a menudo echo de menos al realizar una conversión de datos antigua a una nueva:

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

   _acp = CP_UTF8;
   return W2A( pw );
}

Pero tenga en cuenta que esas macros usan mucho stack - no las use para bucles o bucles recursivos para la misma función - después de usar la macro W2A o A2W - mejor devolver ASAP, por lo que la pila se liberará de la conversión temporal.

Cadena a 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 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 = "おはよう"; es un error

Debe usar wstring directamente:

wstring ws = L"おはよう";

usa este código para convertir tu cadena a 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;
}