C ++ Konversi string (atau karakter *) ke wstring (atau wchar_t *)

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

Bagaimana saya menetapkan konten s ke ws?

Mencari Google dan menggunakan beberapa teknik tetapi mereka tidak dapat menetapkan konten yang tepat. Konten terdistorsi.

Mengasumsikan bahwa string input dalam contoh Anda (お は よ う) adalah UTF-8 yang dikodekan (yang tidak terlihat seperti itu, tetapi mari kita asumsikan itu demi penjelasan ini :-)) representasi dari string Unicode yang Anda minati, maka masalah Anda dapat diselesaikan dengan perpustakaan standar (C ++ 11 dan yang lebih baru) saja.

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

Contoh kompilasi dan runnable online yang lebih panjang:

(Mereka semua menunjukkan contoh yang sama. Hanya ada banyak untuk redundansi ...)

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

Catatan (lama) :

Seperti yang ditunjukkan dalam komentar dan dijelaskan di https://stackoverflow.com/a/17106065/6345 ada beberapa kasus ketika menggunakan perpustakaan standar untuk mengkonversi antara UTF-8 dan UTF-16 mungkin memberikan perbedaan yang tidak terduga dalam hasil pada platform yang berbeda . Untuk konversi yang lebih baik, pertimbangkan std::codecvt_utf8seperti yang dijelaskan pada http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Catatan (baru) :

Karena codecvttajuk sudah usang dalam C ++ 17, beberapa kekhawatiran tentang solusi yang disajikan dalam jawaban ini dimunculkan. Namun, komite standar C ++ menambahkan pernyataan penting di http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0618r0.html mengatakan

komponen perpustakaan ini harus dipensiunkan pada Lampiran D, di samping, sampai penggantian yang sesuai distandarisasi.

Jadi di masa mendatang, codecvtsolusi dalam jawaban ini aman dan portabel.

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

    ws = wsTmp;

    return 0;
}

Pertanyaan Anda kurang spesifik. Sebenarnya, contoh itu adalah kesalahan sintaksis. Namun, std::mbstowcsmungkin itu yang Anda cari.

Ini adalah fungsi C-library dan beroperasi pada buffer, tapi di sini adalah idiom yang mudah digunakan, milik TBohne (sebelumnya 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.

Hanya Windows API, sebelum implementasi C ++ 11, jika seseorang membutuhkannya:

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

Jika Anda menggunakan Windows / Visual Studio dan perlu mengonversi string ke wstring Anda bisa menggunakan:

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

Prosedur yang sama untuk mengonversi wstring ke string (kadang-kadang Anda harus menentukan codepage ):

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

Anda dapat menentukan codepage dan bahkan UTF8 (itu cukup bagus ketika bekerja dengan JNI / Java ). Cara standar untuk mengubah string std :: wstring ke utf8 std :: ditunjukkan dalam jawaban ini .

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

Jika Anda ingin tahu lebih banyak tentang codepages ada artikel menarik tentang Joel tentang Perangkat Lunak: Minimum Yang Mutlak Setiap Pengembang Perangkat Lunak Sepenuhnya, Pasti Harus Tahu Tentang Unicode dan Set Karakter .

Makro CA2W (Konversi Ansi ke Lebar = unicode) ini adalah bagian dari Makro Konversi String ATL dan MFC , termasuk sampel.

Kadang-kadang Anda harus menonaktifkan peringatan keamanan # 4995 ', saya tidak tahu solusi lain (bagi saya itu terjadi ketika saya dikompilasi untuk Windows XP di VS2012).

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

Sunting: Yah, menurut artikel ini artikel oleh Joel tampaknya: "sambil menghibur, itu cukup ringan pada detail teknis yang sebenarnya". Artikel: Apa Yang Harus Semua Programmer Sepenuhnya Ingin Tahu Tentang Pengkodean dan Set Karakter Untuk Bekerja dengan Teks .

Inilah cara menggabungkan string, wstringdan menggabungkan konstanta string ke wstring. Gunakan wstringstreamkelas.

Ini TIDAK berfungsi untuk pengkodean karakter multi-byte. Ini hanya cara bodoh membuang keamanan tipe dan memperluas karakter 7 bit dari std :: string ke dalam 7 bit yang lebih rendah dari setiap karakter std: wstring. Ini hanya berguna jika Anda memiliki string ASCII 7-bit dan Anda perlu memanggil API yang membutuhkan string luas.

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

Dari char* ke wstring:

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

Dari stringkewstring:

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

Perhatikan ini hanya berfungsi dengan baik jika string yang dikonversi hanya berisi karakter ASCII.

menggunakan Boost.Locale:

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

Varian ini adalah favorit saya di kehidupan nyata. Itu mengkonversi input, jika itu valid UTF-8, untuk masing-masing wstring. Jika input rusak, wstringitu dibangun dari byte tunggal. Ini sangat membantu jika Anda tidak benar-benar yakin tentang kualitas data input Anda.

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

Jika Anda memiliki QT dan jika Anda malas menerapkan fungsi dan hal-hal yang dapat Anda gunakan

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

Metode s2ws bekerja dengan baik. Semoga bisa membantu.

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

Berdasarkan pengujian saya sendiri (Pada windows 8, vs2010) mbstowcs sebenarnya dapat merusak string asli, ia hanya bekerja dengan halaman kode ANSI. Jika MultiByteToWideChar / WideCharToMultiByte juga dapat menyebabkan korupsi string - tetapi mereka cenderung mengganti karakter yang tidak mereka kenal dengan '?' tanda tanya, tetapi mbstowc cenderung berhenti ketika bertemu dengan karakter yang tidak dikenal dan memotong string pada saat itu. (Saya telah menguji karakter Vietnam di windows Finlandia).

Jadi lebih suka Multi * -windows fungsi api daripada fungsi ansi C analog.

Juga apa yang saya perhatikan cara terpendek untuk menyandikan string dari satu codepage ke yang lain tidak menggunakan MultiByteToWideChar / WideCharToMultiByte panggilan fungsi api tetapi analog ATL makro mereka: W2A / A2W.

Jadi fungsi analog seperti yang disebutkan di atas akan terdengar seperti:

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

_acp dideklarasikan dalam makro USES_CONVERSION.

Atau juga fungsi yang sering saya lewatkan ketika melakukan konversi data lama ke yang baru:

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

   _acp = CP_UTF8;
   return W2A( pw );
}

Tetapi harap perhatikan bahwa makro itu sangat banyak menggunakan stack - jangan gunakan untuk loop atau loop rekursif untuk fungsi yang sama - setelah menggunakan makro W2A atau A2W - lebih baik untuk mengembalikan ASAP, jadi stack akan dibebaskan dari konversi sementara.

String to 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 ke 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 = "おはよう"; adalah kesalahan.

Anda harus menggunakan wstring secara langsung:

wstring ws = L"おはよう";

gunakan kode ini untuk mengonversi string Anda menjadi 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;
}