C ++ Chuyển đổi chuỗi (hoặc char *) thành chuỗi (hoặc wchar_t *)

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

Làm thế nào tôi có thể gán nội dung của s cho ws?

Tìm kiếm trên google và sử dụng một số kỹ thuật nhưng họ không thể chỉ định nội dung chính xác. Nội dung bị bóp méo.

Giả sử rằng chuỗi đầu vào trong ví dụ của bạn (は) là mã UTF-8 (mà không phải, bởi vẻ bề ngoài của nó, nhưng giả sử nó là vì sự giải thích này :-)) đại diện cho chuỗi Unicode bạn quan tâm, sau đó vấn đề của bạn có thể được giải quyết hoàn toàn chỉ với thư viện chuẩn (C ++ 11 trở lên).

Phiên bả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);

Ví dụ trực tuyến có thể biên dịch và chạy được lâu hơn:

(Tất cả đều hiển thị cùng một ví dụ. Chỉ có nhiều thứ để dự phòng ...)

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

Lưu ý (cũ) :

Như đã chỉ ra trong các nhận xét và được giải thích trong https://stackoverflow.com/a/17106065/6345, có những trường hợp khi sử dụng thư viện chuẩn để chuyển đổi giữa UTF-8 và UTF-16 có thể mang lại sự khác biệt bất ngờ về kết quả trên các nền tảng khác nhau . Để chuyển đổi tốt hơn, hãy xem xét std::codecvt_utf8như được mô tả trên http://en.cppreference.com/w/cpp/locale/codecvt_utf8

Lưu ý (mới) :

Vì codecvttiêu đề không được dùng trong C ++ 17, một số lo lắng về giải pháp được trình bày trong câu trả lời này đã được nêu ra. Tuy nhiên, ủy ban tiêu chuẩn C ++ đã thêm một tuyên bố quan trọng trong http://www.open-std.org/jtc1/sc22/wg21/docs/ con / 2017 / p0618r0.html nói

thành phần thư viện này nên được rút về Phụ lục D, dọc theo, cho đến khi một sự thay thế phù hợp được tiêu chuẩn hóa.

Vì vậy, trong tương lai gần, codecvtgiải pháp trong câu trả lời này là an toàn và di động.

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

    ws = wsTmp;

    return 0;
}

Câu hỏi của bạn không được xác định rõ. Nghiêm túc, ví dụ đó là một lỗi cú pháp. Tuy nhiên, std::mbstowcscó lẽ là những gì bạn đang tìm kiếm.

Đây là một chức năng của thư viện C và hoạt động trên các bộ đệm, nhưng đây là một thành ngữ dễ sử dụng, lịch sự của TBohne (trước đây là 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.

Chỉ API Windows, triển khai trước C ++ 11, trong trường hợp ai đó cần nó:

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

Nếu bạn đang sử dụng Windows / Visual Studio và cần chuyển đổi một chuỗi thành chuỗi, bạn có thể sử dụng:

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

Quy trình tương tự để chuyển đổi một chuỗi thành chuỗi (đôi khi bạn sẽ cần chỉ định một bảng mã ):

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

Bạn có thể chỉ định một bảng mã và thậm chí UTF8 (điều đó khá hay khi làm việc với JNI / Java ). Một cách tiêu chuẩn để chuyển đổi chuỗi std :: w chuỗi thành utf8 std :: chuỗi được hiển thị trong câu trả lời này .

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

Nếu bạn muốn biết thêm về tiền mã hóa, có một bài viết thú vị về Joel trên Phần mềm: Tối thiểu tuyệt đối Mỗi nhà phát triển phần mềm Tuyệt đối, Phải tích cực phải biết về Unicode và Bộ ký tự .

Các macro CA2W (Chuyển đổi Ansi thành Wide = unicode) là một phần của Macro chuyển đổi chuỗi ATL và MFC , bao gồm các mẫu.

Đôi khi bạn sẽ cần phải tắt cảnh báo bảo mật # 4995 ', tôi không biết cách giải quyết khác (với tôi nó xảy ra khi tôi biên dịch cho WindowsXp trong VS2012).

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

Chỉnh sửa: Vâng, theo bài viết này , bài viết của Joel dường như là: "trong khi giải trí, nó khá nhẹ về các chi tiết kỹ thuật thực tế". Bài báo: Điều mà mọi lập trình viên hoàn toàn cần, tích cực cần biết về mã hóa và bộ ký tự để làm việc với văn bản .

Dưới đây là một cách để kết hợp string, wstringvà chuỗi hằng hỗn hợp để wstring. Sử dụng wstringstreamlớp học.

Điều này KHÔNG hoạt động đối với mã hóa ký tự nhiều byte. Đây chỉ là một cách ngu ngốc để loại bỏ sự an toàn của loại và mở rộng các ký tự 7 bit từ std :: chuỗi thành 7 bit thấp hơn của mỗi ký tự của std: wopes. Điều này chỉ hữu ích nếu bạn có chuỗi ASCII 7 bit và bạn cần gọi API yêu cầu chuỗi rộng.

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

Từ char*đến wstring:

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

Từ stringđến wstring:

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

Lưu ý điều này chỉ hoạt động tốt nếu chuỗi được chuyển đổi chỉ chứa các ký tự ASCII.

sử dụng Boost.Locale:

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

Biến thể này của nó là yêu thích của tôi trong cuộc sống thực. Nó chuyển đổi đầu vào, nếu nó là UTF-8 hợp lệ , thành tương ứng wstring. Nếu đầu vào bị hỏng, thì wstringđược xây dựng từ các byte đơn. Điều này cực kỳ hữu ích nếu bạn không thể thực sự chắc chắn về chất lượng dữ liệu đầu vào của mình.

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

Nếu bạn có QT và nếu bạn lười thực hiện một chức năng và công cụ bạn có thể sử dụng

std :: chuỗi str; QString (str) .toStdWString ()

phương pháp s2ws hoạt động tốt. Hy vọng giúp.

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

Dựa trên thử nghiệm của riêng tôi (Trên windows 8, vs2010) mbstowcs thực sự có thể làm hỏng chuỗi gốc, nó chỉ hoạt động với trang mã ANSI. Nếu MultiByteToWideChar / WideCharToMultiByte cũng có thể gây ra tham nhũng chuỗi - nhưng họ có xu hướng thay thế các ký tự mà họ không biết bằng '?' dấu hỏi, nhưng mbstowcs có xu hướng dừng lại khi nó gặp ký tự không xác định và cắt chuỗi tại chính điểm đó. (Tôi đã thử các ký tự tiếng Việt trên các cửa sổ Phần Lan).

Vì vậy, thích chức năng api đa * hơn so với các chức năng tương tự ansi C.

Ngoài ra, điều mà tôi nhận thấy cách ngắn nhất để mã hóa chuỗi từ mã này sang mã khác là không sử dụng các hàm gọi api MultiByteToWideChar / WideCharToMultiByte nhưng các macro ATL tương tự của chúng: W2A / A2W.

Vì vậy, chức năng tương tự như đã đề cập ở trên sẽ nghe như:

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

_acp được khai báo trong macro USES_CONVERSION.

Hoặc cũng là chức năng mà tôi thường bỏ lỡ khi thực hiện chuyển đổi dữ liệu cũ sang dữ liệu mới:

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

   _acp = CP_UTF8;
   return W2A( pw );
}

Nhưng xin lưu ý rằng các macro đó sử dụng nhiều stack - không sử dụng cho các vòng lặp hoặc các vòng lặp đệ quy cho cùng một chức năng - sau khi sử dụng macro W2A hoặc A2W - tốt hơn để trả về ASAP, vì vậy stack sẽ được giải phóng khỏi chuyển đổi tạm thời.

Chuỗi thành chuỗi

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

chuỗi đến chuỗi

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 = "おはよう"; là một lỗi.

Bạn nên sử dụng trực tiếp chuỗi:

wstring ws = L"おはよう";

sử dụng mã này để chuyển đổi chuỗi của bạn thành chuỗi

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