如何：在各種字串類型之間轉換

發行項
08/02/2024

本文說明如何將各種 Visual C++ 字串類型轉換成其他字串。

涵蓋的字串類型包括 char * 、 wchar_t* 、 _bstr_t 、 CComBSTR 、、 CString 、 basic_string 和 System.String 。

在所有情況下，當轉換成新類型時，就會建立字串的複本。對新字串所做的任何變更都不會影響原始字串，反之亦然。

如需轉換窄字串和寬字元串的詳細資訊，請參閱在窄字串與寬字元串之間轉換。

執行範例

若要在 Visual Studio 2022 中執行範例，您可以建立新的 C++ Windows 主控台應用程式。或者，如果您已安裝 C++/CLI 支援，您可以建立 CLR 主控台應用程式（.NET Framework）。

如果您建立 CLR 主控台應用程式，就不需要對編譯器和偵錯工具設定進行下列變更。不過，您必須將新增 #include "pch.h" 至每個範例的頂端。

無論哪種方式，新增 comsuppw.lib 至 專案屬性 > 連結器 > 輸入 > 其他相依性。

如果您建立新的 C++ Windows 主控台應用程式以執行範例，請進行下列專案變更：

將 /clr 和 /Zc:twoPhase- 命令列引數新增至 專案屬性 > C++ > 命令列 > 其他選項。

參數 /clr 會與您建立 C++ Windows 主控台應用程式專案時所設定的某些編譯器參數衝突。下列連結提供可在 IDE 中關閉衝突切換位置的指示：

關閉 [將基本執行時間檢查設定為預設值] ： 專案屬性 > C/C++ > 程式碼產生 > 基本執行時間檢查預設值 > /RTC1
關閉（例外狀況處理模型）： 專案屬性 > C/C++ > 程式碼產生 > 啟用 C++ 例外狀況否 > /EHs
Exchange （偵錯資訊格式）的 /Z7 ： 專案屬性 > C/C++ > 一般 > 偵錯資訊格式 > C7 相容 /Zi
關閉 [Just My Code 偵錯] ： 專案屬性 > C/C++ > 一般 > 支援 Just My Code Debug 否 > /JMC
將偵錯工具類型設定為混合： 專案屬性 > > 偵錯偵錯工具類型 > 混合（.NET Framework）
開啟：專案屬性 > 連結器 > > 偵錯可偵錯元件 > 是（ASSEMBLYDEBUG） /ASSEMBLYDEBUG

範例：轉換來源 `char *`

描述

此範例示範如何從 char * 轉換成上面所列的字串類型。 char *字串（也稱為 C 樣式字串）會使用終止 Null 來表示字串的結尾。 C 樣式字串通常需要每個字元 1 個位元組，但也可以使用 2 個位元組。在下列範例中， char * 字串有時稱為多位元組字元字串，因為從寬 Unicode 字串轉換所產生的字串資料。單一位元組和多位元組字元（ MBCS ）函式可以在字串上 char * 運作。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_char.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;

int main()
{
    // Create and display a C-style string, and then use it
    // to create different kinds of strings.
    const char* orig = "Hello, World!";
    cout << orig << " (char *)" << endl;

    // newsize describes the length of the
    // wchar_t string called wcstring in terms of the number
    // of wide characters, not the number of bytes.
    size_t newsize = strlen(orig) + 1;

    // The following creates a buffer large enough to contain
    // the exact number of characters in the original string
    // in the new format. If you want to add more characters
    // to the end of the string, increase the value of newsize
    // to increase the size of the buffer.
    wchar_t* wcstring = new wchar_t[newsize];

    // Convert char* string to a wchar_t* string.
    size_t convertedChars = 0;
    mbstowcs_s(&convertedChars, wcstring, newsize, orig, _TRUNCATE);
    // Display the result and indicate the type of string that it is.
    wcout << wcstring << L" (wchar_t *)" << endl;
    delete []wcstring;

    // Convert the C-style string to a _bstr_t string.
    _bstr_t bstrt(orig);
    // Append the type of string to the new string
    // and then display the result.
    bstrt += " (_bstr_t)";
    cout << bstrt << endl;

    // Convert the C-style string to a CComBSTR string.
    CComBSTR ccombstr(orig);
    if (ccombstr.Append(L" (CComBSTR)") == S_OK)
    {
        CW2A printstr(ccombstr);
        cout << printstr << endl;
    }

    // Convert the C-style string to a CStringA and display it.
    CStringA cstringa(orig);
    cstringa += " (CStringA)";
    cout << cstringa << endl;

    // Convert the C-style string to a CStringW and display it.
    CStringW cstring(orig);
    cstring += " (CStringW)";
    // To display a CStringW correctly, use wcout and cast cstring
    // to (LPCTSTR).
    wcout << (LPCTSTR)cstring << endl;

    // Convert the C-style string to a basic_string and display it.
    string basicstring(orig);
    basicstring += " (basic_string)";
    cout << basicstring << endl;

    // Convert the C-style string to a System::String and display it.
    String^ systemstring = gcnew String(orig);
    systemstring += " (System::String)";
    Console::WriteLine("{0}", systemstring);
    delete systemstring;
}

Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (basic_string)
Hello, World! (System::String)

範例：轉換來源 `wchar_t *`

描述

此範例示範如何從 wchar_t * 轉換成其他字串類型。數種字串類型，包括 wchar_t * 實作寬字元格式。若要在多位元組與寬字元格式之間轉換字串，您可以使用類似 mbstowcs_s 的單一函式呼叫，或這類 CStringA 類別的建構函式調用。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_wchar_t.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;

int main()
{
    // Create a string of wide characters, display it, and then
    // use this string to create other types of strings.
    const wchar_t* orig = L"Hello, World!";
    wcout << orig << L" (wchar_t *)" << endl;

    // Convert the wchar_t string to a char* string. Record
    // the length of the original string and add 1 to it to
    // account for the terminating null character.
    size_t origsize = wcslen(orig) + 1;
    size_t convertedChars = 0;

    // Use a multibyte string to append the type of string
    // to the new string before displaying the result.
    char strConcat[] = " (char *)";
    size_t strConcatsize = (strlen(strConcat) + 1) * 2;

    // Allocate two bytes in the multibyte output string for every wide
    // character in the input string (including a wide character
    // null). Because a multibyte character can be one or two bytes,
    // you should allot two bytes for each character. Having extra
    // space for the new string isn't an error, but having
    // insufficient space is a potential security problem.
    const size_t newsize = origsize * 2;
    // The new string will contain a converted copy of the original
    // string plus the type of string appended to it.
    char* nstring = new char[newsize + strConcatsize];

    // Put a copy of the converted string into nstring
    wcstombs_s(&convertedChars, nstring, newsize, orig, _TRUNCATE);
    // append the type of string to the new string.
    _mbscat_s((unsigned char*)nstring, newsize + strConcatsize, (unsigned char*)strConcat);
    // Display the result.
    cout << nstring << endl;
    delete []nstring;

    // Convert a wchar_t to a _bstr_t string and display it.
    _bstr_t bstrt(orig);
    bstrt += " (_bstr_t)";
    cout << bstrt << endl;

    // Convert the wchar_t string to a BSTR wide character string
    // by using the ATL CComBSTR wrapper class for BSTR strings.
    // Then display the result.

    CComBSTR ccombstr(orig);
    if (ccombstr.Append(L" (CComBSTR)") == S_OK)
    {
        // CW2A converts the string in ccombstr to a multibyte
        // string in printstr, used here for display output.
        CW2A printstr(ccombstr);
        cout << printstr << endl;
        // The following line of code is an easier way to
        // display wide character strings:
        wcout << (LPCTSTR)ccombstr << endl;
    }

    // Convert a wide wchar_t string to a multibyte CStringA,
    // append the type of string to it, and display the result.
    CStringA cstringa(orig);
    cstringa += " (CStringA)";
    cout << cstringa << endl;

    // Convert a wide character wchar_t string to a wide
    // character CStringW string and append the type of string to it
    CStringW cstring(orig);
    cstring += " (CStringW)";
    // To display a CStringW correctly, use wcout and cast cstring
    // to (LPCTSTR).
    wcout << (LPCTSTR)cstring << endl;

    // Convert the wide character wchar_t string to a
    // basic_string, append the type of string to it, and
    // display the result.
    wstring basicstring(orig);
    basicstring += L" (basic_string)";
    wcout << basicstring << endl;

    // Convert a wide character wchar_t string to a
    // System::String string, append the type of string to it,
    // and display the result.
    String^ systemstring = gcnew String(orig);
    systemstring += " (System::String)";
    Console::WriteLine("{0}", systemstring);
    delete systemstring;
}

Hello, World! (wchar_t *)
Hello, World! (char *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (basic_string)
Hello, World! (System::String)

範例：轉換來源 `_bstr_t`

描述

此範例示範如何從 _bstr_t 轉換成其他字串類型。物件 _bstr_t 會封裝寬字元 BSTR 字串。 BSTR字串具有長度值，而且不會使用 Null 字元來終止字串，但您轉換的字串類型可能需要終止的 Null 字元。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_bstr_t.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;

int main()
{
    // Create a _bstr_t string, display the result, and indicate the
    // type of string that it is.
    _bstr_t orig("Hello, World!");
    wcout << orig << " (_bstr_t)" << endl;

    // Convert the wide character _bstr_t string to a C-style
    // string. To be safe, allocate two bytes for each character
    // in the char* string, including the terminating null.
    const size_t newsize = (orig.length() + 1) * 2;
    char* nstring = new char[newsize];

    // Uses the _bstr_t operator (char *) to obtain a null
    // terminated string from the _bstr_t object for
    // nstring.
    strcpy_s(nstring, newsize, (char*)orig);
    strcat_s(nstring, newsize, " (char *)");
    cout << nstring << endl;
    delete []nstring;

    // Prepare the type of string to append to the result.
    wchar_t strConcat[] = L" (wchar_t *)";
    size_t strConcatLen = wcslen(strConcat) + 1;

    // Convert a _bstr_t to a wchar_t* string.
    const size_t widesize = orig.length() + strConcatLen;
    wchar_t* wcstring = new wchar_t[newsize];
    wcscpy_s(wcstring, widesize, (wchar_t*)orig);
    wcscat_s(wcstring, widesize, strConcat);
    wcout << wcstring << endl;
    delete []wcstring;

    // Convert a _bstr_t string to a CComBSTR string.
    CComBSTR ccombstr((char*)orig);
    if (ccombstr.Append(L" (CComBSTR)") == S_OK)
    {
        CW2A printstr(ccombstr);
        cout << printstr << endl;
    }

    // Convert a _bstr_t to a CStringA string.
    CStringA cstringa(orig.GetBSTR());
    cstringa += " (CStringA)";
    cout << cstringa << endl;

    // Convert a _bstr_t to a CStringW string.
    CStringW cstring(orig.GetBSTR());
    cstring += " (CStringW)";
    // To display a cstring correctly, use wcout and
    // "cast" the cstring to (LPCTSTR).
    wcout << (LPCTSTR)cstring << endl;

    // Convert the _bstr_t to a basic_string.
    string basicstring((char*)orig);
    basicstring += " (basic_string)";
    cout << basicstring << endl;

    // Convert the _bstr_t to a System::String.
    String^ systemstring = gcnew String((char*)orig);
    systemstring += " (System::String)";
    Console::WriteLine("{0}", systemstring);
    delete systemstring;
}

Hello, World! (_bstr_t)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (CComBSTR)
Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (basic_string)
Hello, World! (System::String)

範例：轉換來源 `CComBSTR`

描述

此範例示範如何從 CComBSTR 轉換成其他字串類型。如同 _bstr_t ， CComBSTR 物件會封裝寬字元 BSTR 字串。 BSTR字串具有長度值，且不會使用 Null 字元來終止字串，但您轉換的字串類型可能需要終止 Null。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_ccombstr.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

int main()
{
    // Create and initialize a BSTR string by using a CComBSTR object.
    CComBSTR orig("Hello, World!");
    // Convert the BSTR into a multibyte string, display the result,
    // and indicate the type of string that it is.
    CW2A printstr(orig);
    cout << printstr << " (CComBSTR)" << endl;

    // Convert a wide character CComBSTR string to a
    // regular multibyte char* string. Allocate enough space
    // in the new string for the largest possible result,
    // including space for a terminating null.
    const size_t newsize = (orig.Length() + 1) * 2;
    char* nstring = new char[newsize];

    // Create a string conversion object, copy the result to
    // the new char* string, and display the result.
    CW2A tmpstr1(orig);
    strcpy_s(nstring, newsize, tmpstr1);
    cout << nstring << " (char *)" << endl;
    delete []nstring;

    // Prepare the type of string to append to the result.
    wchar_t strConcat[] = L" (wchar_t *)";
    size_t strConcatLen = wcslen(strConcat) + 1;

    // Convert a wide character CComBSTR string to a wchar_t*.
    // The code first determines the length of the converted string
    // plus the length of the appended type of string, then
    // prepares the final wchar_t string for display.
    const size_t widesize = orig.Length() + strConcatLen;
    wchar_t* wcstring = new wchar_t[widesize];
    wcscpy_s(wcstring, widesize, orig);
    wcscat_s(wcstring, widesize, strConcat);

    // Display the result. Unlike CStringW, a wchar_t doesn't need
    // a cast to (LPCTSTR) with wcout.
    wcout << wcstring << endl;
    delete []wcstring;

    // Convert a wide character CComBSTR to a wide character _bstr_t,
    // append the type of string to it, and display the result.
    _bstr_t bstrt(orig);
    bstrt += " (_bstr_t)";
    cout << bstrt << endl;

    // Convert a wide character CComBSTR to a multibyte CStringA,
    // append the type of string to it, and display the result.
    CStringA cstringa(orig);
    cstringa += " (CStringA)";
    cout << cstringa << endl;

    // Convert a wide character CComBSTR to a wide character CStringW.
    CStringW cstring(orig);
    cstring += " (CStringW)";
    // To display a cstring correctly, use wcout and cast cstring
    // to (LPCTSTR).
    wcout << (LPCTSTR)cstring << endl;

    // Convert a wide character CComBSTR to a wide character
    // basic_string.
    wstring basicstring(orig);
    basicstring += L" (basic_string)";
    wcout << basicstring << endl;

    // Convert a wide character CComBSTR to a System::String.
    String^ systemstring = gcnew String(orig);
    systemstring += " (System::String)";
    Console::WriteLine("{0}", systemstring);
    delete systemstring;
}

Hello, World! (CComBSTR)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (basic_string)
Hello, World! (System::String)

範例：轉換來源 `CString`

描述

此範例示範如何從 CString 轉換成其他字串類型。 CString 是以資料類型為基礎 TCHAR ，這反過來又取決於是否定義符號 _UNICODE 。如果未 _UNICODE 定義， TCHAR 則會定義為 char 且 CString 包含多位元組字元字串;如果 _UNICODE 已定義， TCHAR 則會定義為 wchar_t 且 CString 包含寬字元字串。

CStringA 包含 char 類型，並支援單一位元組或多位元組字元串。 CStringW 是寬字元版本。 CStringA 和 CStringW 不會用來 _UNICODE 判斷其應該如何編譯。 CStringA 和 CStringW 用於此範例，以厘清緩衝區大小配置和輸出處理中的次要差異。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_cstring.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;

int main()
{
    // Set up a multibyte CStringA string.
    CStringA origa("Hello, World!");
    cout << origa << " (CStringA)" << endl;

    // Set up a wide character CStringW string.
    CStringW origw("Hello, World!");
    wcout << (LPCTSTR)origw << L" (CStringW)" << endl;

    // Convert to a char* string from CStringA string
    // and display the result.
    const size_t newsizea = origa.GetLength() + 1;
    char* nstringa = new char[newsizea];
    strcpy_s(nstringa, newsizea, origa);
    cout << nstringa << " (char *)" << endl;
    delete []nstringa;

    // Convert to a char* string from a wide character
    // CStringW string. To be safe, we allocate two bytes for each
    // character in the original string, including the terminating
    // null.
    const size_t newsizew = (origw.GetLength() + 1) * 2;
    char* nstringw = new char[newsizew];
    size_t convertedCharsw = 0;
    wcstombs_s(&convertedCharsw, nstringw, newsizew, origw, _TRUNCATE);
    cout << nstringw << " (char *)" << endl;
    delete []nstringw;

    // Convert to a wchar_t* from CStringA
    size_t convertedCharsa = 0;
    wchar_t* wcstring = new wchar_t[newsizea];
    mbstowcs_s(&convertedCharsa, wcstring, newsizea, origa, _TRUNCATE);
    wcout << wcstring << L" (wchar_t *)" << endl;
    delete []wcstring;

    // Convert to a wide character wchar_t* string from
    // a wide character CStringW string.
    wchar_t* n2stringw = new wchar_t[newsizew];
    wcscpy_s(n2stringw, newsizew, origw);
    wcout << n2stringw << L" (wchar_t *)" << endl;
    delete []n2stringw;

    // Convert to a wide character _bstr_t string from
    // a multibyte CStringA string.
    _bstr_t bstrt(origa);
    bstrt += L" (_bstr_t)";
    wcout << bstrt << endl;

    // Convert to a wide character _bstr_t string from
    // a wide character CStringW string.
    bstr_t bstrtw(origw);
    bstrtw += " (_bstr_t)";
    wcout << bstrtw << endl;

    // Convert to a wide character CComBSTR string from
    // a multibyte character CStringA string.
    CComBSTR ccombstr(origa);
    if (ccombstr.Append(L" (CComBSTR)") == S_OK)
    {
        // Convert the wide character string to multibyte
        // for printing.
        CW2A printstr(ccombstr);
        cout << printstr << endl;
    }

    // Convert to a wide character CComBSTR string from
    // a wide character CStringW string.
    CComBSTR ccombstrw(origw);

    // Append the type of string to it, and display the result.
    if (ccombstrw.Append(L" (CComBSTR)") == S_OK)
    {
        CW2A printstrw(ccombstrw);
        wcout << printstrw << endl;
    }

    // Convert a multibyte character CStringA to a
    // multibyte version of a basic_string string.
    string basicstring(origa);
    basicstring += " (basic_string)";
    cout << basicstring << endl;

    // Convert a wide character CStringW to a
    // wide character version of a basic_string
    // string.
    wstring basicstringw(origw);
    basicstringw += L" (basic_string)";
    wcout << basicstringw << endl;

    // Convert a multibyte character CStringA to a
    // System::String.
    String^ systemstring = gcnew String(origa);
    systemstring += " (System::String)";
    Console::WriteLine("{0}", systemstring);
    delete systemstring;

    // Convert a wide character CStringW to a
    // System::String.
    String^ systemstringw = gcnew String(origw);
    systemstringw += " (System::String)";
    Console::WriteLine("{0}", systemstringw);
    delete systemstringw;
}

Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (char *)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CComBSTR)
Hello, World! (basic_string)
Hello, World! (System::String)

範例：轉換來源 `basic_string`

描述

此範例示範如何從 basic_string 轉換成其他字串類型。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_basic_string.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;

int main()
{
    // Set up a basic_string string.
    string orig("Hello, World!");
    cout << orig << " (basic_string)" << endl;

    // Convert a wide character basic_string string to a multibyte char*
    // string. To be safe, we allocate two bytes for each character
    // in the original string, including the terminating null.
    const size_t newsize = (orig.size() + 1) * 2;

    char* nstring = new char[newsize];
    strcpy_s(nstring, newsize, orig.c_str());
    cout << nstring << " (char *)" << endl;
    delete []nstring;

    // Convert a basic_string string to a wide character
    // wchar_t* string. You must first convert to a char*
    // for this to work.
    const size_t newsizew = orig.size() + 1;
    size_t convertedChars = 0;
    wchar_t* wcstring = new wchar_t[newsizew];
    mbstowcs_s(&convertedChars, wcstring, newsizew, orig.c_str(), _TRUNCATE);
    wcout << wcstring << L" (wchar_t *)" << endl;
    delete []wcstring;

    // Convert a basic_string string to a wide character
    // _bstr_t string.
    _bstr_t bstrt(orig.c_str());
    bstrt += L" (_bstr_t)";
    wcout << bstrt << endl;

    // Convert a basic_string string to a wide character
    // CComBSTR string.
    CComBSTR ccombstr(orig.c_str());
    if (ccombstr.Append(L" (CComBSTR)") == S_OK)
    {
        // Make a multibyte version of the CComBSTR string
        // and display the result.
        CW2A printstr(ccombstr);
        cout << printstr << endl;
    }

    // Convert a basic_string string into a multibyte
    // CStringA string.
    CStringA cstring(orig.c_str());
    cstring += " (CStringA)";
    cout << cstring << endl;

    // Convert a basic_string string into a wide
    // character CStringW string.
    CStringW cstringw(orig.c_str());
    cstringw += L" (CStringW)";
    wcout << (LPCTSTR)cstringw << endl;

    // Convert a basic_string string to a System::String
    String^ systemstring = gcnew String(orig.c_str());
    systemstring += " (System::String)";
    Console::WriteLine("{0}", systemstring);
    delete systemstring;
}

Hello, World! (basic_string)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (System::String)

範例：轉換來源 `System::String`

描述

此範例示範如何從寬字元 System：：String 轉換成其他字串類型。

如需執行和偵錯此範例的相關資訊，請參閱執行範例。

代碼

// convert_from_system_string.cpp
// compile with: /clr /Zc:twoPhase- /link comsuppw.lib

#include <iostream>
#include <stdlib.h>
#include <string>

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

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

int main()
{
    // Set up a System::String and display the result.
    String^ orig = gcnew String("Hello, World!");
    Console::WriteLine("{0} (System::String)", orig);

    // Obtain a pointer to the System::String in order to
    // first lock memory into place, so that the
    // Garbage Collector (GC) cannot move that object
    // while we call native functions.
    pin_ptr<const wchar_t> wch = PtrToStringChars(orig);

    // Make a copy of the System::String as a multibyte
    // char* string. Allocate two bytes in the multibyte
    // output string for every wide character in the input
    // string, including space for a terminating null.
    size_t origsize = wcslen(wch) + 1;
    const size_t newsize = origsize * 2;
    size_t convertedChars = 0;
    char* nstring = new char[newsize];
    wcstombs_s(&convertedChars, nstring, newsize, wch, _TRUNCATE);
    cout << nstring << " (char *)" << endl;
    delete []nstring;

    // Convert a wide character System::String to a
    // wide character wchar_t* string.
    const size_t newsizew = origsize;
    wchar_t* wcstring = new wchar_t[newsizew];
    wcscpy_s(wcstring, newsizew, wch);
    wcout << wcstring << L" (wchar_t *)" << endl;
    delete []wcstring;

    // Convert a wide character System::String to a
    // wide character _bstr_t string.
    _bstr_t bstrt(wch);
    bstrt += " (_bstr_t)";
    cout << bstrt << endl;

    // Convert a wide character System::String
    // to a wide character CComBSTR string.
    CComBSTR ccombstr(wch);
    if (ccombstr.Append(L" (CComBSTR)") == S_OK)
    {
        // Make a multibyte copy of the CComBSTR string
        // and display the result.
        CW2A printstr(ccombstr);
        cout << printstr << endl;
    }

    // Convert a wide character System::String to
    // a multibyte CStringA string.
    CStringA cstring(wch);
    cstring += " (CStringA)";
    cout << cstring << endl;

    // Convert a wide character System::String to
    // a wide character CStringW string.
    CStringW cstringw(wch);
    cstringw += " (CStringW)";
    wcout << (LPCTSTR)cstringw << endl;

    // Convert a wide character System::String to
    // a wide character basic_string.
    wstring basicstring(wch);
    basicstring += L" (basic_string)";
    wcout << basicstring << endl;

    delete orig;
}

Hello, World! (System::String)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CStringA)
Hello, World! (CStringW)
Hello, World! (basic_string)

在窄字串和寬字元串之間轉換

舊版 C 和 Windows 應用程式在處理窄字串和寬字元串時，會使用字碼頁，而不是 Unicode 編碼。

.NET 字串是 UTF-16，但 ATL CStringA 是窄字串，而從寬到窄的 WideCharToMultiByte 轉換是由 Win32 函式執行。將 C 樣式（C 樣式 CHAR* CHAR* 是 .NET byte* ）轉換成字串時， MultiByteToWideChar 會呼叫相反的 Win32 函式。

這兩個函式都依賴字碼頁的 Windows 概念;不是文化特性的 .NET 概念。若要變更系統字碼頁，請使用使用主控台 輸入搜尋方塊 > [區域] （變更日期、時間或數位格式） > 管理員原則 > 變更系統地區設定的區域設定。 Region >

en-US在 Windows 的語言版本上，字碼頁預設為 1033。如果您安裝不同的 Windows 語言，則會有不同的字碼頁。您可以使用控制台加以變更。

執行寬到窄轉換的方式 CStringA 不符，以及執行窄到寬轉換的方式 gcnew string(CHAR*) 。 CStringA 會傳遞 CP_THREAD_ACP ，這表示使用目前的 執行緒 字碼頁至縮小轉換方法。但是 string.ctor(sbyte*) 傳遞 CP_ACP ，這表示使用目前的系統字碼頁，以擴大轉換方法。如果系統和執行緒字碼頁不相符，可能會導致來回資料損毀。

若要調和這項差異，請使用常數 _CONVERSION_DONT_USE_THREAD_LOCALE 來取得轉換以使用 CP_ACP （例如 .NET）而非 CP_THREAD_ACP 。如需詳細資訊，請參閱_CONVERSION_DONT_USE_THREAD_LOCALE。

另一種方法是使用 pinvoke 呼叫 GetThreadLocale 。使用傳 LCID 回的來建立 CultureInfo 。 CultureInfo.TextInfo然後使用取得要用於轉換的字碼頁。

另請參閱

ATL 和 MFC 字串轉換宏
 CString 與 C 樣式字串相關的作業
 作法：將標準 String 轉換為 System::String
作法：轉換為 System::String 標準 String
作法：轉換為 System::String wchar_t* 或 char*
使用進行程式設計 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）

共用方式為

如何：在各種字串類型之間轉換

執行範例

範例：轉換來源 `char *`

描述

代碼

範例：轉換來源 `wchar_t *`

描述

代碼

範例：轉換來源 `_bstr_t`

描述

代碼

範例：轉換來源 `CComBSTR`

描述

代碼

範例：轉換來源 `CString`

描述

代碼

範例：轉換來源 `basic_string`

描述

代碼

範例：轉換來源 `System::String`

描述

代碼

在窄字串和寬字元串之間轉換

另請參閱

意見反應

其他資源

共用方式為

如何：在各種字串類型之間轉換

執行範例

範例：轉換來源 char *

描述

代碼

範例：轉換來源 wchar_t *

描述

代碼

範例：轉換來源 _bstr_t

描述

代碼

範例：轉換來源 CComBSTR

描述

代碼

範例：轉換來源 CString

描述

代碼

範例：轉換來源 basic_string

描述

代碼

範例：轉換來源 System::String

描述

代碼

在窄字串和寬字元串之間轉換

另請參閱

意見反應

其他資源

範例：轉換來源 `char *`

範例：轉換來源 `wchar_t *`

範例：轉換來源 `_bstr_t`

範例：轉換來源 `CComBSTR`

範例：轉換來源 `CString`

範例：轉換來源 `basic_string`

範例：轉換來源 `System::String`