c++ - que - wstring to string
C++ Convierte cadena(o char*) a wstring(o wchar_t*) (13)
string s = "おはよう";
wstring ws = FUNCTION(s, ws);
¿Cómo asignaré 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.
API de Windows solamente, 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);
}
Aquí hay una manera de combinar string , wstring y constantes de cadenas mixtas en wstring . Use la clase wstringstream .
#include <sstream>
std::string narrow = "narrow";
std::wstring wide = "wide";
std::wstringstream cls;
cls << " abc " << narrow.c_str() << L" def " << wide.c_str();
std::wstring total= cls.str();
Asumiendo que la cadena de entrada en su ejemplo (お は よ is) está codificada en UTF-8 (lo cual no 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 se puede resolver 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 ...)
Nota (antigua) :
Como se señaló en los comentarios y se explicó en https://.com/a/17106065/6345 hay casos en los 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_utf8 como se describe en http://en.cppreference.com/w/cpp/locale/codecvt_utf8
Nota (nueva) :
Dado que el encabezado codecvt está en desuso en C ++ 17, algunos se preocupan por 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 al Anexo D, al costado, hasta que se estandarice un reemplazo adecuado.
Entonces, en el futuro previsible, la solución codecvt en esta respuesta es segura y portátil.
Basado en 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 las cadenas, pero tienden a reemplazar los caracteres que no conocen con ''?'' signos de interrogación, pero mbstowcs tiende a detenerse cuando encuentra un carácter desconocido y corta la cuerda en ese mismo punto. (He probado caracteres vietnamitas en ventanas finlandesas).
Por lo tanto, prefiera la función api Multi-Windows sobre las funciones análogas C ansi.
Además, lo que he notado es que la forma más corta de codificar una cadena de una página de códigos a otra no es usar llamadas a la función api MultiByteToWideChar / WideCharToMultiByte, sino sus macros analógicas ATL: W2A / A2W.
Así que la función analógica como se mencionó anteriormente podría sonar como:
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 extraño cuando realizo la conversión de datos 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 el uso de macros en gran medida - no use para bucles o bucles recursivos para la misma función - después de usar W2A o A2W macro - mejor para devolver lo antes posible, por lo que la pila se liberará de la conversión temporal.
De char* a wstring :
char* str = "hello worlddd";
wstring wstr (str, str+strlen(str));
De string a 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.
El método s2ws funciona bien. Hope 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;
}
Esta variante es mi favorita en la vida real. Convierte la entrada, si es válida UTF-8, a la wstring respectiva. Si la entrada está dañada, el wstring se 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 está usando 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 en una cadena (a veces deberá 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());
Podría especificar una página de códigos e incluso UTF8 (eso es muy bueno cuando se trabaja con JNI / Java ).
CA2W ca2w(str, CP_UTF8);
Si desea obtener más información acerca de las páginas de códigos, hay un artículo interesante sobre Joel en Software: el mínimo absoluto que todo desarrollador de software debe saber absolutamente sobre Unicode y conjuntos de caracteres .
Estas macros CA2W (Convertir Ansi en Ancho = Unicode) son parte de las macros de conversión de cadenas ATL y MFC , muestras incluidas.
A veces tendrá que desactivar la advertencia de seguridad # 4995 '', no sé de otra solución alternativa (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: "mientras entretiene, es bastante ligero en los detalles técnicos reales". Artículo: Lo que todo programador debe saber sobre la codificación y juegos de caracteres para trabajar con texto .
Tu pregunta no está especificada. Estrictamente, ese ejemplo es un error de sintaxis. Sin embargo, std::mbstowcs es probablemente lo que estás buscando.
Es una función de biblioteca C y opera en búferes, 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.
usando Boost.Locale:
ws = boost::locale::conv::utf_to_utf<wchar_t>(s);
use este código para convertir su 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;
}
string s = "おはよう"; es un error
Deberías usar wstring directamente:
wstring ws = L"おはよう";
int StringToWString(std::wstring &ws, const std::string &s)
{
std::wstring wsTmp(s.begin(), s.end());
ws = wsTmp;
return 0;
}