Cách thực hiện: Chuyển đổi giữa các loại chuỗi khác nhau

• Bài báo
• 06/06/2022
• 20 phút để đọc

Trong bài viết này

Bài viết này hướng dẫn cách chuyển đổi các loại chuỗi Visual C ++ khác nhau thành các chuỗi khác.

Các loại chuỗi được đề cập bao gồm char * , wchar_t * , _bstr_t , < mã> CComBSTR , CString , basic_string và System.String .

Trong mọi trường hợp, một bản sao của chuỗi được tạo ra khi được chuyển đổi sang kiểu mới. Mọi thay đổi được thực hiện đối với chuỗi mới sẽ không ảnh hưởng đến chuỗi gốc và ngược lại.

Để biết thêm thông tin cơ bản về cách chuyển đổi chuỗi hẹp và rộng, hãy xem Chuyển đổi giữa chuỗi hẹp và chuỗi rộng .

Chạy các ví dụ

Để chạy các ví dụ trong Visual Studio 2022, bạn có thể tạo Ứng dụng Bảng điều khiển Windows C ++ mới hoặc nếu bạn đã cài đặt hỗ trợ C ++ / CLI, bạn có thể tạo Ứng dụng Bảng điều khiển CLR (.NET Framework).

Nếu bạn tạo Ứng dụng bảng điều khiển CLR, bạn không phải thực hiện các thay đổi sau đối với cài đặt trình biên dịch và trình gỡ lỗi. Tuy nhiên, bạn sẽ cần thêm #include "pch.h" vào đầu mỗi ví dụ.

Dù bằng cách nào, hãy thêm comsuppw.lib vào Thuộc tính dự án & gt; Trình liên kết & gt; Đầu vào & gt; Sự phụ thuộc bổ sung .

Nếu bạn tạo một ứng dụng C ++ Windows Console mới để chạy các ví dụ, hãy thực hiện các thay đổi dự án sau:

• Thêm các đối số dòng lệnh / clr và / Zc: twoPhase- vào Thuộc tính dự án & gt; C ++ & gt; Dòng lệnh & gt; Tùy chọn bổ sung .

Công tắc / clr xung đột với một số công tắc trình biên dịch được đặt khi bạn tạo dự án Ứng dụng bảng điều khiển Windows C ++. Các liên kết sau cung cấp hướng dẫn về vị trí trong IDE bạn có thể tắt các công tắc xung đột:

Ví dụ: Chuyển đổi từ char *

Mô tả

Ví dụ này trình bày cách chuyển đổi từ char * sang các loại chuỗi được liệt kê ở trên. Chuỗi char * (còn được gọi là chuỗi kiểu C) sử dụng giá trị null kết thúc để chỉ ra phần cuối của chuỗi. Chuỗi kiểu C thường yêu cầu 1 byte cho mỗi ký tự, nhưng cũng có thể sử dụng 2 byte. Trong các ví dụ dưới đây, các chuỗi char * đôi khi được gọi là chuỗi ký tự nhiều byte vì dữ liệu chuỗi là kết quả của việc chuyển đổi từ các chuỗi Unicode rộng. Các hàm byte đơn và ký tự nhiều byte ( MBCS ) có thể hoạt động trên các chuỗi char * .

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_char.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;

int main ()
{
    // Tạo và hiển thị một chuỗi kiểu C, sau đó sử dụng nó
    // để tạo các loại chuỗi khác nhau.
    const char * orig = "Xin chào, Thế giới!";
    cout & lt; & lt; orig & lt; & lt; "(char *)" & lt; & lt; endl;

    // newsize mô tả độ dài của
    // chuỗi wchar_t được gọi là wcstring theo số
    // của các ký tự rộng, không phải số byte.
    size_t newsize = strlen (orig) + 1;

    // Phần sau tạo một bộ đệm đủ lớn để chứa
    // số ký tự chính xác trong chuỗi ban đầu
    // ở định dạng mới. Nếu bạn muốn thêm nhiều ký tự
    // đến cuối chuỗi, tăng giá trị của newsize
    // để tăng kích thước của bộ đệm.
    wchar_t * wcstring = new wchar_t [newsize];

    // Chuyển chuỗi char * thành chuỗi wchar_t *.
    size_t convertChars = 0;
    mbstowcs_s (& amp; convertChars, wcstring, newsize, orig, _TRUNCATE);
    // Hiển thị kết quả và cho biết loại chuỗi của nó.
    wcout & lt; & lt; wcstring & lt; & lt; L "(wchar_t *)" & lt; & lt; endl;
    xóa [] wcstring;

    // Chuyển chuỗi kiểu C thành chuỗi _bstr_t.
    _bstr_t bstrt (orig);
    // Nối loại chuỗi vào chuỗi mới
    // và sau đó hiển thị kết quả.
    bstrt + = "(_bstr_t)";
    cout & lt; & lt; bstrt & lt; & lt; endl;

    // Chuyển chuỗi kiểu C thành chuỗi CComBSTR.
    CComBSTR ccombstr (orig);
    if (ccombstr.Append (L "(CComBSTR)") == S_OK)
    {
        CW2A printstr (ccombstr);
        cout & lt; & lt; printstr & lt; & lt; endl;
    }

    // Chuyển chuỗi C-style thành CStringA và hiển thị nó.
    CStringA cstringa (orig);
    cstringa + = "(CStringA)";
    cout & lt; & lt; cstringa & lt; & lt; endl;

    // Chuyển chuỗi C-style thành CStringW và hiển thị nó.
    CStringW cstring (orig);
    cstring + = "(CStringW)";
    // Để hiển thị CStringW một cách chính xác, hãy sử dụng wcout và ép kiểu cstring
    // tới (LPCTSTR).
    wcout & lt; & lt; (LPCTSTR) chuỗi & lt; & lt; endl;

    // Chuyển chuỗi C-style thành chuỗi_cơ_bản và hiển thị nó.
    chuỗi basicstring (orig);
    basicstring + = "(basic_string)";
    cout & lt; & lt; chuỗi cơ bản & lt; & lt; endl;

    // Chuyển chuỗi C-style thành System :: String và hiển thị nó.
    String ^ systemstring = gcnew String (orig);
    systemstring + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstring);
    xóa chuỗi hệ thống;
}
 

  Xin chào, Thế giới! (ký tự *)
Chào thế giới! (wchar_t *)
Chào thế giới! (_bstr_t)
Chào thế giới! (CComBSTR)
Chào thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (basic_string)
Chào thế giới! (Hệ thống :: Chuỗi)
 

Ví dụ: Chuyển đổi từ wchar_t *

Mô tả

Ví dụ này trình bày cách chuyển đổi từ wchar_t * sang các loại chuỗi khác. Một số kiểu chuỗi, bao gồm wchar_t * , triển khai các định dạng ký tự rộng. Để chuyển đổi một chuỗi giữa định dạng multibyte và định dạng ký tự rộng, bạn có thể sử dụng một lệnh gọi hàm đơn lẻ như mbstowcs_s hoặc lệnh gọi hàm tạo cho một lớp như CStringA .

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_wchar_t.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;

int main ()
{
    // Tạo một chuỗi ký tự rộng, hiển thị nó, sau đó
    // sử dụng chuỗi này để tạo các loại chuỗi khác.
    const wchar_t * orig = L "Xin chào, Thế giới!";
    wcout & lt; & lt; orig & lt; & lt; L "(wchar_t *)" & lt; & lt; endl;

    // Chuyển chuỗi wchar_t thành chuỗi char *. Ghi lại
    // độ dài của chuỗi ban đầu và thêm 1 vào
    // giải thích cho ký tự null kết thúc.
    size_t origsize = wcslen (orig) + 1;
    size_t convertChars = 0;

    // Sử dụng chuỗi multibyte để nối loại chuỗi
    // đến chuỗi mới trước khi hiển thị kết quả.
    char strConcat [] = "(char *)";
    size_t strConcatsize = (strlen (strConcat) + 1) * 2;

    // Phân bổ hai byte trong chuỗi đầu ra multibyte cho mỗi chiều rộng
    // ký tự trong chuỗi đầu vào (bao gồm một ký tự rộng
    // vô giá trị). Vì một ký tự nhiều byte có thể là một hoặc hai byte,
    // bạn nên phân bổ hai byte cho mỗi ký tự. Có thêm
    // khoảng trắng cho chuỗi mới không phải là lỗi, nhưng có
    // không đủ dung lượng là một vấn đề bảo mật tiềm ẩn.
    const size_t newsize = origsize * 2;
    // Chuỗi mới sẽ chứa một bản sao được chuyển đổi của bản gốc
    // chuỗi cộng với loại chuỗi được thêm vào nó.
    char * nstring = new char [newsize + strConcatsize];

    // Đặt một bản sao của chuỗi đã chuyển đổi thành nstring
    wcstombs_s (& amp; convertChars, nstring, newsize, orig, _TRUNCATE);
    // nối loại chuỗi vào chuỗi mới.
    _mbscat_s ((không dấu *) nstring, newsize + strConcatsize, (không dấu *) strConcat);
    // Hiển thị kết quả.
    cout & lt; & lt; nstring & lt; & lt; endl;
    xóa [] nstring;

    // Chuyển đổi wchar_t thành chuỗi _bstr_t và hiển thị nó.
    _bstr_t bstrt (orig);
    bstrt + = "(_bstr_t)";
    cout & lt; & lt; bstrt & lt; & lt; endl;

    // Chuyển đổi chuỗi wchar_t thành chuỗi ký tự rộng BSTR
    // bằng cách sử dụng lớp trình bao bọc ATL CComBSTR cho chuỗi BSTR.
    // Sau đó hiển thị kết quả.

    CComBSTR ccombstr (orig);
    if (ccombstr.Append (L "(CComBSTR)") == S_OK)
    {
        // CW2A chuyển đổi chuỗi trong ccombstr thành multibyte
        // chuỗi trong printstr, được sử dụng ở đây để hiển thị đầu ra.
        CW2A printstr (ccombstr);
        cout & lt; & lt; printstr & lt; & lt; endl;
        // Dòng mã sau đây là một cách dễ dàng hơn để
        // hiển thị chuỗi ký tự rộng:
        wcout & lt; & lt; (LPCTSTR) ccombstr & lt; & lt; endl;
    }

    // Chuyển đổi một chuỗi wchar_t rộng thành một CStringA nhiều byte,
    // nối loại chuỗi vào nó và hiển thị kết quả.
    CStringA cstringa (orig);
    cstringa + = "(CStringA)";
    cout & lt; & lt; cstringa & lt; & lt; endl;

    // Chuyển đổi một chuỗi wchar_t ký tự rộng thành một chuỗi rộng
    // chuỗi ký tự CStringW và nối loại chuỗi vào nó
    CStringW cstring (orig);
    cstring + = "(CStringW)";
    // Để hiển thị CStringW một cách chính xác, hãy sử dụng wcout và ép kiểu cstring
    // tới (LPCTSTR).
    wcout & lt; & lt; (LPCTSTR) chuỗi & lt; & lt; endl;

    // Chuyển đổi chuỗi wchar_t ký tự rộng thành một
    // basic_string, nối loại chuỗi vào nó và
    // hiển thị kết quả.
    wstring basicstring (orig);
    basicstring + = L "(basic_string)";
    wcout & lt; & lt; chuỗi cơ bản & lt; & lt; endl;

    // Chuyển đổi một chuỗi wchar_t ký tự rộng thành một
    // Hệ thống :: Chuỗi chuỗi, nối loại chuỗi vào nó,
    // và hiển thị kết quả.
    String ^ systemstring = gcnew String (orig);
    systemstring + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstring);
    xóa chuỗi hệ thống;
}
 

  Xin chào, Thế giới! (wchar_t *)
Chào thế giới! (ký tự *)
Chào thế giới! (_bstr_t)
Chào thế giới! (CComBSTR)
Chào thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (basic_string)
Chào thế giới! (Hệ thống :: Chuỗi)
 

Ví dụ: Chuyển đổi từ _bstr_t

Mô tả

Ví dụ này trình bày cách chuyển đổi từ _bstr_t sang các loại chuỗi khác. Đối tượng _bstr_t đóng gói các chuỗi ký tự rộng BSTR . Chuỗi BSTR có giá trị độ dài và không sử dụng ký tự null để kết thúc chuỗi, nhưng loại chuỗi bạn chuyển đổi sang có thể yêu cầu ký tự null kết thúc.

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_bstr_t.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;

int main ()
{
    // Tạo chuỗi _bstr_t, hiển thị kết quả và cho biết
    // loại chuỗi của nó.
    _bstr_t orig ("Xin chào, Thế giới!");
    wcout & lt; & lt; orig & lt; & lt; "(_bstr_t)" & lt; & lt; endl;

    // Chuyển đổi chuỗi ký tự rộng _bstr_t thành kiểu C
    // sợi dây. Để an toàn, hãy phân bổ hai byte cho mỗi ký tự
    // trong chuỗi char *, bao gồm cả giá trị null kết thúc.
    const size_t newsize = (orig.length () + 1) * 2;
    char * nstring = new char [newsize];

    // Sử dụng toán tử _bstr_t (char *) để lấy giá trị rỗng
    // chuỗi kết thúc từ đối tượng _bstr_t cho
    // nstring.
    strcpy_s (nstring, newsize, (char *) orig);
    strcat_s (nstring, newsize, "(char *)");
    cout & lt; & lt; nstring & lt; & lt; endl;
    xóa [] nstring;

    // Chuẩn bị kiểu chuỗi để thêm vào kết quả.
    wchar_t strConcat [] = L "(wchar_t *)";
    size_t strConcatLen = wcslen (strConcat) + 1;

    // Chuyển đổi _bstr_t thành chuỗi wchar_t *.
    const size_t wideize = orig.length () + strConcatLen;
    wchar_t * wcstring = new wchar_t [newsize];
    wcscpy_s (wcstring, wideize, (wchar_t *) orig);
    wcscat_s (wcstring, wideize, strConcat);
    wcout & lt; & lt; wcstring & lt; & lt; endl;
    xóa [] wcstring;

    // Chuyển đổi chuỗi _bstr_t thành chuỗi CComBSTR.
    CComBSTR ccombstr ((char *) orig);
    if (ccombstr.Append (L "(CComBSTR)") == S_OK)
    {
        CW2A printstr (ccombstr);
        cout & lt; & lt; printstr & lt; & lt; endl;
    }

    // Chuyển đổi một _bstr_t thành một chuỗi CStringA.
    CStringA cstringa (orig.GetBSTR ());
    cstringa + = "(CStringA)";
    cout & lt; & lt; cstringa & lt; & lt; endl;

    // Chuyển đổi _bstr_t thành chuỗi CStringW.
    CStringW cstring (orig.GetBSTR ());
    cstring + = "(CStringW)";
    // Để hiển thị một chuỗi chính xác, hãy sử dụng wcout và
    // "ép kiểu" chuỗi tới (LPCTSTR).
    wcout & lt; & lt; (LPCTSTR) chuỗi & lt; & lt; endl;

    // Chuyển đổi _bstr_t thành một chuỗi_cơ bản.
    string basicstring ((char *) orig);
    basicstring + = "(basic_string)";
    cout & lt; & lt; chuỗi cơ bản & lt; & lt; endl;

    // Chuyển _bstr_t thành System :: String.
    String ^ systemstring = gcnew String ((char *) orig);
    systemstring + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstring);
    xóa chuỗi hệ thống;
}
 

  Xin chào, Thế giới! (_bstr_t)
Chào thế giới! (ký tự *)
Chào thế giới! (wchar_t *)
Chào thế giới! (CComBSTR)
Chào thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (basic_string)
Chào thế giới! (Hệ thống :: Chuỗi)
 

Ví dụ: Chuyển đổi từ CComBSTR

Mô tả

Ví dụ này trình bày cách chuyển đổi từ CComBSTR sang các loại chuỗi khác. Giống như _bstr_t , đối tượng CComBSTR đóng gói các chuỗi ký tự rộng BSTR . Chuỗi BSTR có giá trị độ dài và không sử dụng ký tự null để kết thúc chuỗi, nhưng loại chuỗi bạn chuyển đổi sang có thể yêu cầu ký tự null kết thúc.

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_ccombstr.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;
sử dụng không gian tên Hệ thống :: Runtime :: InteropServices;

int main ()
{
    // Tạo và khởi tạo chuỗi BSTR bằng cách sử dụng đối tượng CComBSTR.
    CComBSTR orig ("Xin chào, Thế giới!");
    // Chuyển BSTR thành một chuỗi multibyte, hiển thị kết quả,
    // và cho biết loại chuỗi đó là.
    CW2A printstr (orig);
    cout & lt; & lt; printstr & lt; & lt; "(CComBSTR)" & lt; & lt; endl;

    // Chuyển đổi một chuỗi CComBSTR ký tự rộng thành một
    // chuỗi ký tự * nhiều byte thông thường. Phân bổ đủ không gian
    // trong chuỗi mới cho kết quả lớn nhất có thể,
    // bao gồm khoảng trắng cho giá trị null kết thúc.
    const size_t newsize = (orig.Length () + 1) * 2;
    char * nstring = new char [newsize];

    // Tạo đối tượng chuyển đổi chuỗi, sao chép kết quả vào
    // chuỗi ký tự * mới và hiển thị kết quả.
    CW2A tmpstr1 (orig);
    strcpy_s (nstring, newsize, tmpstr1);
    cout & lt; & lt; nstring & lt; & lt; "(char *)" & lt; & lt; endl;
    xóa [] nstring;

    // Chuẩn bị kiểu chuỗi để thêm vào kết quả.
    wchar_t strConcat [] = L "(wchar_t *)";
    size_t strConcatLen = wcslen (strConcat) + 1;

    // Chuyển đổi chuỗi CComBSTR ký tự rộng thành wchar_t *.
    // Đoạn mã đầu tiên xác định độ dài của chuỗi được chuyển đổi
    // cộng với độ dài của loại chuỗi được thêm vào, sau đó
    // chuẩn bị chuỗi wchar_t cuối cùng để hiển thị.
    const size_t wideize = orig.Length () + strConcatLen;
    wchar_t * wcstring = new wchar_t [kích thước rộng];
    wcscpy_s (wcstring, wideize, orig);
    wcscat_s (wcstring, wideize, strConcat);

    // Hiển thị kết quả. Không giống như CStringW, wchar_t không cần
    // truyền đến (LPCTSTR) với wcout.
    wcout & lt; & lt; wcstring & lt; & lt; endl;
    xóa [] wcstring;

    // Chuyển đổi một ký tự rộng CComBSTR thành một ký tự rộng _bstr_t,
    // nối loại chuỗi vào nó và hiển thị kết quả.
    _bstr_t bstrt (orig);
    bstrt + = "(_bstr_t)";
    cout & lt; & lt; bstrt & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng CComBSTR thành một CStringA nhiều byte,
    // nối loại chuỗi vào nó và hiển thị kết quả.
    CStringA cstringa (orig);
    cstringa + = "(CStringA)";
    cout & lt; & lt; cstringa & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng CComBSTR thành một ký tự rộng CStringW.
    CStringW cstring (orig);
    cstring + = "(CStringW)";
    // Để hiển thị một chuỗi chính xác, hãy sử dụng wcout và ép kiểu chuỗi
    // tới (LPCTSTR).
    wcout & lt; & lt; (LPCTSTR) chuỗi & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng CComBSTR thành một ký tự rộng
    // basic_string.
    wstring basicstring (orig);
    basicstring + = L "(basic_string)";
    wcout & lt; & lt; chuỗi cơ bản & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng CComBSTR thành System :: String.
    String ^ systemstring = gcnew String (orig);
    systemstring + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstring);
    xóa chuỗi hệ thống;
}
 

  Xin chào, Thế giới! (CComBSTR)
Chào thế giới! (ký tự *)
Chào thế giới! (wchar_t *)
Chào thế giới! (_bstr_t)
Chào thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (basic_string)
Chào thế giới! (Hệ thống :: Chuỗi)
 

Ví dụ: Chuyển đổi từ CString

Mô tả

Ví dụ này trình bày cách chuyển đổi từ CString sang các loại chuỗi khác. CString dựa trên kiểu dữ liệu TCHAR , do đó phụ thuộc vào việc ký hiệu _UNICODE có được xác định hay không. Nếu _UNICODE không được xác định, thì TCHAR được xác định là char và CString chứa một chuỗi ký tự nhiều byte; nếu _UNICODE được xác định, thì TCHAR được xác định là wchar_t và CString chứa chuỗi ký tự rộng.

CStringA chứa loại char và hỗ trợ chuỗi một byte hoặc nhiều byte. CStringW là phiên bản ký tự rộng. CStringA và CStringW không sử dụng _UNICODE để xác định cách chúng nên biên dịch. CStringA và CStringW được sử dụng trong ví dụ này để làm rõ những khác biệt nhỏ trong phân bổ kích thước bộ đệm và xử lý đầu ra.

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_cstring.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;

int main ()
{
    // Thiết lập một chuỗi CStringA nhiềubyte.
    CStringA origa ("Xin chào, Thế giới!");
    cout & lt; & lt; origa & lt; & lt; "(CStringA)" & lt; & lt; endl;

    // Thiết lập chuỗi CStringW ký tự rộng.
    CStringW origw ("Xin chào, Thế giới!");
    wcout & lt; & lt; (LPCTSTR) origw & lt; & lt; L "(CStringW)" & lt; & lt; endl;

    // Chuyển thành chuỗi char * từ chuỗi CStringA
    // và hiển thị kết quả.
    const size_t newsizea = origa.GetLength () + 1;
    char * nstringa = new char [newsizea];
    strcpy_s (nstringa, newsizea, origa);
    cout & lt; & lt; nstringa & lt; & lt; "(char *)" & lt; & lt; endl;
    xóa [] nstringa;

    // Chuyển thành chuỗi ký tự char * từ một ký tự rộng
    // Chuỗi CStringW. Để an toàn, chúng tôi phân bổ hai byte cho mỗi
    // ký tự trong chuỗi ban đầu, bao gồm cả phần cuối
    // vô giá trị.
    const size_t newsizew = (origw.GetLength () + 1) * 2;
    char * nstringw = new char [newsizew];
    size_t đã chuyển đổiCharsw = 0;
    wcstombs_s (& amp; convertCharsw, nstringw, newsizew, origw, _TRUNCATE);
    cout & lt; & lt; nstringw & lt; & lt; "(char *)" & lt; & lt; endl;
    xóa [] nstringw;

    // Chuyển đổi thành wchar_t * từ CStringA
    size_t đã chuyển đổiCharsa = 0;
    wchar_t * wcstring = new wchar_t [newsizea];
    mbstowcs_s (& amp; convertCharsa, wcstring, newsizea, origa, _TRUNCATE);
    wcout & lt; & lt; wcstring & lt; & lt; L "(wchar_t *)" & lt; & lt; endl;
    xóa [] wcstring;

    // Chuyển đổi thành một ký tự rộng wchar_t * chuỗi từ
    // một chuỗi CStringW ký tự rộng.
    wchar_t * n2stringw = new wchar_t [newsizew];
    wcscpy_s (n2stringw, newsizew, origw);
    wcout & lt; & lt; n2stringw & lt; & lt; L "(wchar_t *)" & lt; & lt; endl;
    xóa [] n2stringw;

    // Chuyển thành chuỗi _bstr_t ký tự rộng từ
    // một chuỗi CStringA nhiều byte.
    _bstr_t bstrt (origa);
    bstrt + = L "(_bstr_t)";
    wcout & lt; & lt; bstrt & lt; & lt; endl;

    // Chuyển thành chuỗi _bstr_t ký tự rộng từ
    // một chuỗi CStringW ký tự rộng.
    bstr_t bstrtw (origw);
    bstrtw + = "(_bstr_t)";
    wcout & lt; & lt; bstrtw & lt; & lt; endl;

    // Chuyển đổi sang chuỗi CComBSTR ký tự rộng từ
    // một chuỗi CStringA nhiều ký tự.
    CComBSTR ccombstr (origa);
    if (ccombstr.Append (L "(CComBSTR)") == S_OK)
    {
        // Chuyển đổi chuỗi ký tự rộng thành multibyte
        // Để in.
        CW2A printstr (ccombstr);
        cout & lt; & lt; printstr & lt; & lt; endl;
    }

    // Chuyển đổi sang chuỗi CComBSTR ký tự rộng từ
    // một chuỗi CStringW ký tự rộng.
    CComBSTR ccombstrw (origw);

    // Nối kiểu chuỗi vào nó và hiển thị kết quả.
    if (ccombstrw.Append (L "(CComBSTR)") == S_OK)
    {
        CW2A printstrw (ccombstrw);
        wcout & lt; & lt; printstrw & lt; & lt; endl;
    }

    // Chuyển đổi một ký tự nhiềubyte CStringA thành một
    // phiên bản multibyte của chuỗi basic_string.
    chuỗi cơ bản (origa);
    basicstring + = "(basic_string)";
    cout & lt; & lt; chuỗi cơ bản & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng CStringW thành một
    // phiên bản ký tự rộng của chuỗi cơ bản
    // sợi dây.
    wstring basicstringw (origw);
    basicstringw + = L "(basic_string)";
    wcout & lt; & lt; basicstringw & lt; & lt; endl;

    // Chuyển đổi một ký tự nhiềubyte CStringA thành một
    // Hệ thống :: Chuỗi.
    String ^ systemstring = gcnew String (origa);
    systemstring + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstring);
    xóa chuỗi hệ thống;

    // Chuyển đổi một ký tự rộng CStringW thành một
    // Hệ thống :: Chuỗi.
    String ^ systemstringw = gcnew String (origw);
    systemstringw + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstringw);
    xóa systemstringw;
}
 

  Xin chào, Thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (ký tự *)
Chào thế giới! (ký tự *)
Chào thế giới! (wchar_t *)
Chào thế giới! (wchar_t *)
Chào thế giới! (_bstr_t)
Chào thế giới! (_bstr_t)
Chào thế giới! (CComBSTR)
Chào thế giới! (CComBSTR)
Chào thế giới! (basic_string)
Chào thế giới! (Hệ thống :: Chuỗi)
 

Ví dụ: Chuyển đổi từ basic_string

Mô tả

Ví dụ này trình bày cách chuyển đổi từ basic_string sang các loại chuỗi khác.

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_basic_string.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;

int main ()
{
    // Thiết lập chuỗi basic_string.
    string orig ("Xin chào, Thế giới!");
    cout & lt; & lt; orig & lt; & lt; "(basic_string)" & lt; & lt; endl;

    // Chuyển đổi chuỗi basic_string ký tự rộng thành một ký tự nhiều byte *
    // sợi dây. Để an toàn, chúng tôi phân bổ hai byte cho mỗi ký tự
    // trong chuỗi ban đầu, bao gồm cả giá trị null kết thúc.
    const size_t newsize = (orig.size () + 1) * 2;

    char * nstring = new char [newsize];
    strcpy_s (nstring, newsize, orig.c_str ());
    cout & lt; & lt; nstring & lt; & lt; "(char *)" & lt; & lt; endl;
    xóa [] nstring;

    // Chuyển chuỗi basic_string thành một ký tự rộng
    // chuỗi wchar_t *. Trước tiên, bạn phải chuyển đổi thành một ký tự *
    // để cái này hoạt động.
    const size_t newsizew = orig.size () + 1;
    size_t convertChars = 0;
    wchar_t * wcstring = new wchar_t [newsizew];
    mbstowcs_s (& amp; convertChars, wcstring, newsizew, orig.c_str (), _TRUNCATE);
    wcout & lt; & lt; wcstring & lt; & lt; L "(wchar_t *)" & lt; & lt; endl;
    xóa [] wcstring;

    // Chuyển chuỗi basic_string thành một ký tự rộng
    // Chuỗi _bstr_t.
    _bstr_t bstrt (orig.c_str ());
    bstrt + = L "(_bstr_t)";
    wcout & lt; & lt; bstrt & lt; & lt; endl;

    // Chuyển chuỗi basic_string thành một ký tự rộng
    // Chuỗi CComBSTR.
    CComBSTR ccombstr (orig.c_str ());
    if (ccombstr.Append (L "(CComBSTR)") == S_OK)
    {
        // Tạo phiên bản multibyte của chuỗi CComBSTR
        // và hiển thị kết quả.
        CW2A printstr (ccombstr);
        cout & lt; & lt; printstr & lt; & lt; endl;
    }

    // Chuyển chuỗi basic_string thành multibyte
    // Chuỗi CStringA.
    CStringA cstring (orig.c_str ());
    cstring + = "(CStringA)";
    cout & lt; & lt; chuỗi & lt; & lt; endl;

    // Chuyển một chuỗi basic_string thành một chuỗi rộng
    // chuỗi ký tự CStringW.
    CStringW cstringw (orig.c_str ());
    cstringw + = L "(CStringW)";
    wcout & lt; & lt; (LPCTSTR) cstringw & lt; & lt; endl;

    // Chuyển chuỗi basic_string thành System :: String
    String ^ systemstring = gcnew String (orig.c_str ());
    systemstring + = "(Hệ thống :: Chuỗi)";
    Console :: WriteLine ("{0}", systemstring);
    xóa chuỗi hệ thống;
}
 

  Xin chào, Thế giới! (basic_string)
Chào thế giới! (ký tự *)
Chào thế giới! (wchar_t *)
Chào thế giới! (_bstr_t)
Chào thế giới! (CComBSTR)
Chào thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (Hệ thống :: Chuỗi)
 

Ví dụ: Chuyển đổi từ System :: String

Mô tả

Ví dụ này trình bày cách chuyển đổi từ một ký tự rộng System :: String sang các loại chuỗi khác.

Để biết thông tin về cách chạy và gỡ lỗi ví dụ này, hãy xem Chạy ví dụ .

Mã

 // convert_from_system_string.cpp
// biên dịch với: / clr / Zc: twoPhase- / link comsuppw.lib

#include & lt; iostream & gt;
#include & lt; stdlib.h & gt;
#include & lt; string & gt;

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"

sử dụng không gian tên std;
sử dụng hệ thống không gian tên;
sử dụng không gian tên Hệ thống :: Runtime :: InteropServices;

int main ()
{
    // Thiết lập System :: String và hiển thị kết quả.
    String ^ orig = gcnew String ("Xin chào, Thế giới!");
    Console :: WriteLine ("{0} (System :: String)", orig);

    // Lấy một con trỏ đến System :: String để
    // đầu tiên khóa bộ nhớ vào vị trí, để
    // Trình thu gom rác (GC) không thể di chuyển đối tượng đó
    // trong khi chúng ta gọi các hàm bản địa.
    pin_ptr & lt; const wchar_t & gt; wch = PtrToStringChars (orig);

    // Tạo một bản sao của System :: String dưới dạng multibyte
    // chuỗi ký tự *. Phân bổ hai byte trong multibyte
    // đầu ra chuỗi cho mọi ký tự rộng trong đầu vào
    // chuỗi, bao gồm khoảng trắng cho giá trị null kết thúc.
    size_t origsize = wcslen (wch) + 1;
    const size_t newsize = origsize * 2;
    size_t convertChars = 0;
    char * nstring = new char [newsize];
    wcstombs_s (& amp; convertChars, nstring, newsize, wch, _TRUNCATE);
    cout & lt; & lt; nstring & lt; & lt; "(char *)" & lt; & lt; endl;
    xóa [] nstring;

    // Chuyển đổi một ký tự rộng System :: String thành
    // ký tự rộng wchar_t * string.
    const size_t newsizew = origsize;
    wchar_t * wcstring = new wchar_t [newsizew];
    wcscpy_s (wcstring, newsizew, wch);
    wcout & lt; & lt; wcstring & lt; & lt; L "(wchar_t *)" & lt; & lt; endl;
    xóa [] wcstring;

    // Chuyển đổi một ký tự rộng System :: String thành
    // ký tự rộng _bstr_t string.
    _bstr_t bstrt (wch);
    bstrt + = "(_bstr_t)";
    cout & lt; & lt; bstrt & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng System :: String
    // đến một chuỗi CComBSTR ký tự rộng.
    CComBSTR ccombstr (wch);
    if (ccombstr.Append (L "(CComBSTR)") == S_OK)
    {
        // Tạo bản sao nhiều byte của chuỗi CComBSTR
        // và hiển thị kết quả.
        CW2A printstr (ccombstr);
        cout & lt; & lt; printstr & lt; & lt; endl;
    }

    // Chuyển đổi một ký tự rộng System :: String thành
    // một chuỗi CStringA nhiều byte.
    CStringA cstring (wch);
    cstring + = "(CStringA)";
    cout & lt; & lt; chuỗi & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng System :: String thành
    // một chuỗi CStringW ký tự rộng.
    CStringW cstringw (wch);
    cstringw + = "(CStringW)";
    wcout & lt; & lt; (LPCTSTR) cstringw & lt; & lt; endl;

    // Chuyển đổi một ký tự rộng System :: String thành
    // một ký tự rộng basic_string.
    wstring basicstring (wch);
    basicstring + = L "(basic_string)";
    wcout & lt; & lt; chuỗi cơ bản & lt; & lt; endl;

    xóa orig;
}
 

  Xin chào, Thế giới! (Hệ thống :: Chuỗi)
Chào thế giới! (ký tự *)
Chào thế giới! (wchar_t *)
Chào thế giới! (_bstr_t)
Chào thế giới! (CComBSTR)
Chào thế giới! (CStringA)
Chào thế giới! (CStringW)
Chào thế giới! (basic_string)
 

Chuyển đổi giữa các chuỗi hẹp và rộng

Các ứng dụng Windows và C cũ sử dụng các trang mã thay vì mã hóa Unicode khi xử lý các chuỗi hẹp và chuỗi rộng.

Chuỗi .NET là UTF-16, nhưng CStringA của ATL là một chuỗi hẹp và việc chuyển đổi từ rộng sang hẹp được thực hiện bởi WideCharToMultiByte Win32. Khi chuyển đổi C-style CHAR * (C-style CHAR * là một .NET byte * ) thành một chuỗi, Win32 ngược lại hàm, MultiByteToWideChar được gọi.

Cả hai chức năng đều dựa trên khái niệm Windows về một trang mã; không phải là khái niệm .NET của một nền văn hóa. Để thay đổi trang mã hệ thống, hãy sử dụng cài đặt khu vực bằng Bảng điều khiển & gt; nhập Vùng vào hộp tìm kiếm & gt; Khu vực (thay đổi định dạng ngày, giờ hoặc số) & gt; Hành chính & gt; Thay đổi ngôn ngữ hệ thống .

Trên phiên bản ngôn ngữ en-US của Windows, trang mã được mặc định là 1033. Nếu bạn cài đặt ngôn ngữ khác của Windows, trang đó sẽ có trang mã khác. Bạn có thể thay đổi nó bằng cách sử dụng bảng điều khiển.

Có sự không khớp trong cách CStringA thực hiện chuyển đổi từ rộng sang hẹp và cách mà gcnew string (CHAR *) thực hiện chuyển đổi từ hẹp sang rộng. CStringA chuyển CP_THREAD_ACP , có nghĩa là sử dụng trang mã luồng hiện tại, sang phương pháp chuyển đổi thu hẹp. Nhưng string.ctor (sbyte *) chuyển CP_ACP , có nghĩa là sử dụng trang mã hệ thống hiện tại, sang phương pháp chuyển đổi mở rộng. Nếu hệ thống và các trang mã chuỗi không khớp nhau, nó có thể gây ra hỏng dữ liệu khứ hồi.

Để điều chỉnh sự khác biệt này, hãy sử dụng hằng số _CONVERSION_DONT_USE_THREAD_LOCALE) để nhận chuyển đổi sang sử dụng CP_ACP (như .NET) thay vì CP_THREAD_ACP . Để biết thêm thông tin, hãy xem _CONVERSION_DONT_USE_THREAD_LOCALE .

Một cách tiếp cận khác là sử dụng pinvoke để gọi GetThreadLocale . Sử dụng LCID được trả về để tạo CultureInfo . Sau đó, sử dụng CultureInfo.TextInfo để lấy trang mã sử dụng trong quá trình chuyển đổi.

Xem thêm

Macro chuyển đổi chuỗi ATL và MFC
CString hoạt động liên quan đến chuỗi kiểu C
Cách: chuyển đổi String chuẩn thành System :: String
Cách: chuyển đổi System :: String sang String
tiêu chuẩn
Cách: chuyển đổi System :: String thành wchar_t * hoặc char *
Lập trình với CComBSTR
mbstowcs_s, _mbstowcs_s_l
wcstombs_s, _wcstombs_s_l
strcpy_s, wcscpy_s, _mbscpy_s
strcat_s, wcscat_s, _mbscat_s
pin_ptr (C ++ / CLI)