C ++ Konvertiere String (oder char *) in wstring (oder wchar_t *)

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

Wie würde ich den Inhalt von s ws zuweisen?

Google gesucht und einige Techniken verwendet, aber sie können nicht den genauen Inhalt zuweisen. Der Inhalt ist verzerrt.

Angenommen, die Eingabezeichenfolge in Ihrem Beispiel (お は よ う) ist eine UTF-8-codierte Darstellung (was anscheinend nicht der Fall ist, aber nehmen wir an, dass dies der Erklärung dient :-)) einer Unicode-Zeichenfolge Wenn Sie dies interessieren, kann Ihr Problem allein mit der Standardbibliothek (C ++ 11 und neuer) vollständig gelöst werden.

Die TL; DR-Version:

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

Längeres online kompilierbares und ausführbares Beispiel:

(Sie alle zeigen das gleiche Beispiel. Es gibt nur viele für Redundanz ...)

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

Anmerkung (alt) :

Wie in den Kommentaren erwähnt und unter https://stackoverflow.com/a/17106065/6345 erläutert, kann es vorkommen, dass die Verwendung der Standardbibliothek zum Konvertieren zwischen UTF-8 und UTF-16 zu unerwarteten Unterschieden bei den Ergebnissen auf verschiedenen Plattformen führt . Beachten Sie für eine bessere Konvertierung std::codecvt_utf8die Beschreibung unter http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Hinweis (neu) :

Da der codecvtHeader in C ++ 17 veraltet ist, wurden einige Bedenken hinsichtlich der in dieser Antwort vorgestellten Lösung geäußert. Allerdings fügte das C ++ Normenausschuss eine wichtige Aussage in http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html sagen

Diese Bibliothekskomponente sollte nebenbei in Anhang D eingestellt werden, bis ein geeigneter Ersatz standardisiert ist.

In absehbarer Zeit ist die codecvtLösung in dieser Antwort sicher und tragbar.

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

    ws = wsTmp;

    return 0;
}

Ihre Frage ist nicht genau spezifiziert. Genau genommen ist dieses Beispiel ein Syntaxfehler. Es std::mbstowcsist jedoch wahrscheinlich das, wonach Sie suchen.

Es ist eine C-Bibliotheksfunktion und arbeitet mit Puffern, aber hier ist eine benutzerfreundliche Redewendung, mit freundlicher Genehmigung von TBohne (ehemals 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.

Nur Windows-API, vor der Implementierung von C ++ 11, falls jemand sie benötigt:

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

Wenn Sie Windows / Visual Studio verwenden und eine Zeichenfolge in wstring konvertieren müssen, können Sie Folgendes verwenden:

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

Gleiches Verfahren zum Konvertieren einer Zeichenfolge in eine Zeichenfolge (manchmal müssen Sie eine Codepage angeben ):

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

Sie können eine Codepage und sogar UTF8 angeben (das ist ziemlich gut, wenn Sie mit JNI / Java arbeiten ). In dieser Antwort wird eine Standardmethode zum Konvertieren eines std :: wstring in utf8 std :: string gezeigt .

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

Wenn Sie mehr über Codepages erfahren möchten, gibt es einen interessanten Artikel über Joel über Software: Das absolute Minimum, das jeder Softwareentwickler unbedingt über Unicode und Zeichensätze wissen muss .

Diese CA2W-Makros (Convert Ansi to Wide = Unicode) sind Teil der ATL- und MFC-String-Konvertierungsmakros , einschließlich Beispielen.

Manchmal müssen Sie die Sicherheitswarnung # 4995 'deaktivieren. Ich kenne keine andere Problemumgehung (für mich passiert dies, wenn ich in VS2012 für Windows XP kompiliert habe).

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

Bearbeiten: Nun, laut diesem Artikel scheint der Artikel von Joel zu sein: "Während unterhaltsam, ist es ziemlich leicht auf tatsächlichen technischen Details". Artikel: Was jeder Programmierer unbedingt positiv über Codierung und Zeichensätze wissen muss, um mit Text arbeiten zu können .

Hier ist eine Möglichkeit string, wstringString-Konstanten zu kombinieren und zu mischen wstring. Verwenden Sie die wstringstreamKlasse.

Dies funktioniert NICHT für Mehrbyte-Zeichencodierungen. Dies ist nur eine blöde Methode, um die Typensicherheit wegzuwerfen und 7-Bit-Zeichen von std :: string in die unteren 7 Bits jedes Zeichens von std: wstring zu erweitern. Dies ist nur nützlich, wenn Sie über 7-Bit-ASCII-Zeichenfolgen verfügen und eine API aufrufen müssen, für die breite Zeichenfolgen erforderlich sind.

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

Von char*bis wstring:

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

Von stringbis wstring:

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

Beachten Sie, dass dies nur gut funktioniert, wenn die zu konvertierende Zeichenfolge nur ASCII-Zeichen enthält.

mit Boost.Locale:

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

Diese Variante ist mein Favorit im wirklichen Leben. Es konvertiert die Eingabe, wenn sie UTF-8 gültig ist , in die entsprechende wstring. Wenn die Eingabe beschädigt ist, wstringwird die aus den einzelnen Bytes aufgebaut. Dies ist äußerst hilfreich, wenn Sie sich über die Qualität Ihrer Eingabedaten nicht sicher sein können.

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

Wenn Sie QT haben und faul sind, eine Funktion und Dinge zu implementieren, die Sie verwenden können

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

Methode s2ws funktioniert gut. Hoffnung hilft.

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

Basierend auf meinen eigenen Tests (unter Windows 8, vs2010) können mbstowcs tatsächlich die ursprüngliche Zeichenfolge beschädigen. Sie funktionieren nur mit der ANSI-Codepage. Wenn MultiByteToWideChar / WideCharToMultiByte auch eine Beschädigung von Zeichenfolgen verursachen kann, ersetzen sie jedoch Zeichen, die sie nicht kennen, durch '?' Fragezeichen, aber mbstowcs neigt dazu anzuhalten, wenn es auf ein unbekanntes Zeichen stößt und an dieser Stelle eine Zeichenfolge abschneidet. (Ich habe vietnamesische Schriftzeichen an finnischen Fenstern getestet).

Ziehen Sie daher die Multi * -Fenster-API-Funktion den analogen Ansi C-Funktionen vor.

Ich habe auch festgestellt, dass der kürzeste Weg zum Codieren von Zeichenfolgen von einer Codepage zur anderen darin besteht, nicht die API-Funktionsaufrufe MultiByteToWideChar / WideCharToMultiByte zu verwenden, sondern deren analoge ATL-Makros: W2A / A2W.

Die oben erwähnte analoge Funktion klingt also wie folgt:

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

_acp wird im Makro USES_CONVERSION deklariert.

Oder auch eine Funktion, die ich oft vermisse, wenn ich alte Daten in neue konvertiere:

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

   _acp = CP_UTF8;
   return W2A( pw );
}

Beachten Sie jedoch, dass diese Makros stark gestapelt sind - nicht für Schleifen oder rekursive Schleifen für dieselbe Funktion - nach Verwendung des W2A- oder A2W-Makros - besser so schnell wie möglich zurückgeben, damit der Stapel von der temporären Konvertierung befreit wird.

String zu 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 zu 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 = "おはよう"; ist ein Fehler.

Sie sollten wstring direkt verwenden:

wstring ws = L"おはよう";

Verwenden Sie diesen Code, um Ihren String in wstring zu konvertieren

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