Vorgehensweise: Konvertieren zwischen verschiedenen Zeichenfolgentypen

Artikel
10/12/2023

In diesem Artikel wird gezeigt, wie verschiedene Visual C++-Zeichenfolgentypen in andere Zeichenfolgen konvertiert werden.

Die Zeichenfolgentypen, die abgedeckt werden, umfassen char *, , wchar_t*, _bstr_t, CComBSTR, , CString, und basic_stringSystem.String.

In allen Fällen wird beim Konvertieren in den neuen Typ eine Kopie der Zeichenfolge erstellt. Alle An der neuen Zeichenfolge vorgenommenen Änderungen wirken sich nicht auf die ursprüngliche Zeichenfolge aus, und umgekehrt.

Weitere Hintergrundinformationen zum Konvertieren schmaler und breiter Zeichenfolgen finden Sie unter Konvertieren zwischen schmalen Zeichenfolgen und breiten Zeichenfolgen.

Ausführen der Beispiele

Zum Ausführen der Beispiele in Visual Studio 2022 können Sie eine neue C++-Windows-Konsolen-App erstellen. Oder wenn Sie die C++/CLI-Unterstützung installiert haben, können Sie eine CLR-Konsolen-App (.NET Framework) erstellen.

Wenn Sie eine CLR-Konsolen-App erstellen, müssen Sie die folgenden Änderungen an den Compiler- und Debuggereinstellungen nicht vornehmen. Sie müssen jedoch oben in jedem Beispiel hinzufügen #include "pch.h" .

Fügen Sie comsuppw.lib auf beide Weise zusätzliche Abhängigkeiten zu Project Properties>Linker>hinzu.>

Wenn Sie eine neue C++-Windows-Konsolen-App zum Ausführen der Beispiele erstellen, nehmen Sie die folgenden Projektänderungen vor:

Fügen Sie die /clr Argumente und /Zc:twoPhase- Befehlszeilenargumente zu Project-Eigenschaften>C++>-Befehlszeilenoptionen>hinzu.

Der /clr Switch tritt in Konflikt mit einigen Compileroptionen auf, die festgelegt werden, wenn Sie ein C++-Projekt für windows-Konsolen-App erstellen. Die folgenden Links enthalten Anweisungen dazu, wo Sie in der IDE die widersprüchlichen Schalter deaktivieren können:

Deaktivieren /RTC1 (Standard-Laufzeitüberprüfungen festlegen): Standardüberprüfungen für Project-Eigenschaften>C/C++>-Codegenerierung>– Standardüberprüfungen>
Deaktivieren (Ausnahmebehandlungsmodell): Project-Eigenschaften>C/C++-Codegenerierung>Aktivieren von C++>-Ausnahmen>Nein/EHs
Exchange (Debuginformationsformat) für /Z7: Project Properties>C/C++>General>Debug Information Format>C7 compatible/Zi
Deaktivieren (nur mein Codedebugging): Project-Eigenschaften>C/C++>: Allgemeine>Unterstützung nur für das Debuggen>von Code/JMC
Festlegen des Debuggertyps auf gemischt: Debugdebuggertyp>"Project>Properties>Mixed" (.NET Framework)
Aktivieren: Project properties>Linker>Debugging Debuggable>Assembly>Yes (ASSEMBLYDEBUG) /ASSEMBLYDEBUG

Beispiel: Konvertieren von `char *`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie Sie von einem char * in die oben aufgeführten Zeichenfolgentypen konvertieren. Eine char * Zeichenfolge (auch als C-Style-Zeichenfolge bezeichnet) verwendet einen endenden Nullwert, um das Ende der Zeichenfolge anzugeben. Zeichenfolgen im C-Stil erfordern in der Regel 1 Byte pro Zeichen, können aber auch 2 Byte verwenden. In den folgenden Beispielen werden Zeichenfolgen aufgrund der Zeichenfolgendaten, die aus der Konvertierung aus breiten Unicode-Zeichenfolgen resultieren, char * manchmal als Multibyte-Zeichenfolgen bezeichnet. Einzelbyte- und Multibyte-Zeichenfunktionen (MBCS) können char *-Zeichenfolgen verarbeiten.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Beispiel: Konvertieren von `wchar_t *`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie sie von einem wchar_t * in andere Zeichenfolgentypen konvertiert werden. Mehrere Zeichenfolgentypen, einschließlich wchar_t *, implementieren Breitzeichenformate. Sie können einen einzelnen Funktionsaufruf wie mbstowcs_s oder einen Konstruktoraufruf für eine Klasse wie CStringA verwenden, um eine Zeichenfolge vom Multibyte- in das Breitzeichenformat zu konvertieren bzw. umgekehrt.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Beispiel: Konvertieren von `_bstr_t`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie sie von einem _bstr_t in andere Zeichenfolgentypen konvertiert werden. Das _bstr_t Objekt kapselt breite BSTR Zeichenfolgen. Eine BSTR Zeichenfolge hat einen Längenwert und verwendet kein NULL-Zeichen, um die Zeichenfolge zu beenden, aber der Zeichenfolgentyp, in den Sie konvertieren, erfordert möglicherweise ein endendes NULL-Zeichen.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Beispiel: Konvertieren von `CComBSTR`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie sie von einem CComBSTR in andere Zeichenfolgentypen konvertiert werden. Wie _bstr_tfolgt kapselt ein CComBSTR Objekt breite BSTR Zeichenfolgen. Eine BSTR Zeichenfolge hat einen Längenwert und verwendet kein NULL-Zeichen, um die Zeichenfolge zu beenden, aber der von Ihnen konvertierte Zeichenfolgentyp erfordert möglicherweise einen endenden Nullwert.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Beispiel: Konvertieren von `CString`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie sie von einem CString in andere Zeichenfolgentypen konvertiert werden. CString basiert auf dem TCHAR Datentyp, der wiederum davon abhängt, ob das Symbol _UNICODE definiert ist. Wenn _UNICODE sie nicht definiert ist, wird definiert, TCHAR um eine Multibyte-Zeichenfolge zu sein char und CString eine Multibyte-Zeichenfolge zu enthalten. Ist _UNICODE diese definiert, wird definiert wchar_t und TCHAR CString enthält eine breite Zeichenfolge.

CStringA enthält den char Typ und unterstützt Single-Byte- oder Multibyte-Zeichenfolgen. CStringW ist die breite Zeichenversion. CStringA und CStringW verwenden Sie nicht _UNICODE , um zu bestimmen, wie sie kompiliert werden sollen. CStringA und CStringW werden in diesem Beispiel verwendet, um kleinere Unterschiede in der Puffergrößenzuordnung und Ausgabebehandlung aufzuklären.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Beispiel: Konvertieren von `basic_string`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie sie von einem basic_string in andere Zeichenfolgentypen konvertiert werden.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Beispiel: Konvertieren von `System::String`

Beschreibung

In diesem Beispiel wird veranschaulicht, wie sie von einem breiten Zeichensystem ::String in andere Zeichenfolgentypen konvertiert werden.

Informationen zum Ausführen und Debuggen dieses Beispiels finden Sie unter Ausführen der Beispiele.

Code

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

Konvertieren zwischen schmalen und breiten Zeichenfolgen

Ältere C- und Windows-Apps verwenden Codeseiten anstelle von Unicode-Codierungen bei der Behandlung von schmalen Zeichenfolgen und breiten Zeichenfolgen.

.NET-Zeichenfolgen sind UTF-16, aber ATL ist CStringA eine schmale Zeichenfolge, und die Konvertierung von breit in schmal wird von der WideCharToMultiByte Win32-Funktion ausgeführt. Beim Konvertieren einer C-Formatvorlage (eine C-Formatvorlage CHAR* CHAR* ist ein .NET byte*) in eine Zeichenfolge wird die entgegengesetzte Win32-Funktion MultiByteToWideChar aufgerufen.

Beide Funktionen basieren auf dem Windows-Konzept einer Codepage; nicht das .NET-Konzept einer Kultur. Um die Systemcodeseite zu ändern, verwenden Sie die Regionseinstellung mithilfe von Systemsteuerung> in Region das Suchfeld> Region eingeben (Datums-, Uhrzeit- oder Zahlenformate ändern)>Administratives>Gebietsschema ändern.

In einer en-US Sprachversion von Windows ist die Codepage standardmäßig auf 1033 festgelegt. Wenn Sie eine andere Sprache von Windows installieren, gibt es eine andere Codepage. Sie können sie über die Systemsteuerung ändern.

Es gibt eine Nichtübereinstimmung in der Art und Weise, wie CStringA eine breite bis schmale Konvertierung durchgeführt wird, und die Art und Weise, wie gcnew string(CHAR*) eine schmale bis breite Konvertierung durchgeführt wird. CStringA übergibt CP_THREAD_ACP, was bedeutet, dass die aktuelle Threadcodeseite an die schmale Konvertierungsmethode verwendet wird. Dies bedeutet CP_ACPjedochstring.ctor(sbyte*), dass die aktuelle Systemcodeseite an die Erweiterungskonvertierungsmethode verwendet werden soll. Wenn die System- und Threadcodeseiten nicht übereinstimmen, kann dies zu einer Beschädigung von Roundtripdaten führen.

Um diesen Unterschied abzugleichen, verwenden Sie die Konstante _CONVERSION_DONT_USE_THREAD_LOCALE), um die Konvertierung zu verwenden CP_ACP (z. B. .NET) anstelle von CP_THREAD_ACP. Weitere Informationen finden Sie unter _CONVERSION_DONT_USE_THREAD_LOCALE.

Ein weiterer Ansatz besteht darin, zum Anrufen GetThreadLocalezu verwendenpinvoke. Verwenden Sie die zurückgegebene LCID Zum Erstellen einer CultureInfo. Verwenden Sie CultureInfo.TextInfo dann die Codeseite, die in der Konvertierung verwendet werden soll.

Siehe auch

ATL- und MFC-Zeichenfolgenkonvertierungsmakros
CString Vorgänge im Zusammenhang mit Zeichenfolgen im C-Stil
Vorgehensweise: Konvertieren von Standard String in System::String
Vorgehensweise: Konvertieren System::String in Standard String
Vorgehensweise: Konvertieren System::String in wchar_t* oder char*
Programmieren mit 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)

Freigeben über

Vorgehensweise: Konvertieren zwischen verschiedenen Zeichenfolgentypen

Ausführen der Beispiele

Beispiel: Konvertieren von `char *`

Beschreibung

Code

Beispiel: Konvertieren von `wchar_t *`

Beschreibung

Code

Beispiel: Konvertieren von `_bstr_t`

Beschreibung

Code

Beispiel: Konvertieren von `CComBSTR`

Beschreibung

Code

Beispiel: Konvertieren von `CString`

Beschreibung

Code

Beispiel: Konvertieren von `basic_string`

Beschreibung

Code

Beispiel: Konvertieren von `System::String`

Beschreibung

Code

Konvertieren zwischen schmalen und breiten Zeichenfolgen

Siehe auch

Feedback

Zusätzliche Ressourcen

Freigeben über

Vorgehensweise: Konvertieren zwischen verschiedenen Zeichenfolgentypen

Ausführen der Beispiele

Beispiel: Konvertieren von char *

Beschreibung

Code

Beispiel: Konvertieren von wchar_t *

Beschreibung

Code

Beispiel: Konvertieren von _bstr_t

Beschreibung

Code

Beispiel: Konvertieren von CComBSTR

Beschreibung

Code

Beispiel: Konvertieren von CString

Beschreibung

Code

Beispiel: Konvertieren von basic_string

Beschreibung

Code

Beispiel: Konvertieren von System::String

Beschreibung

Code

Konvertieren zwischen schmalen und breiten Zeichenfolgen

Siehe auch

Feedback

Zusätzliche Ressourcen

Beispiel: Konvertieren von `char *`

Beispiel: Konvertieren von `wchar_t *`

Beispiel: Konvertieren von `_bstr_t`

Beispiel: Konvertieren von `CComBSTR`

Beispiel: Konvertieren von `CString`

Beispiel: Konvertieren von `basic_string`

Beispiel: Konvertieren von `System::String`