Procedura: Eseguire la conversione tra vari tipi di stringa

Articolo
10/12/2023

Questo articolo illustra come convertire vari tipi di stringa di Visual C++ in altre stringhe.

I tipi di stringhe trattati includono char *, wchar_t*, _bstr_t, CComBSTRCString, basic_string, e System.String.

In tutti i casi, una copia della stringa viene eseguita quando viene convertita nel nuovo tipo. Le modifiche apportate alla nuova stringa non influiscono sulla stringa originale e viceversa.

Per altre informazioni di base sulla conversione di stringhe strette e larghe, vedere Conversione tra stringhe strette e stringhe wide.

Eseguire gli esempi

Per eseguire gli esempi in Visual Studio 2022, è possibile creare una nuova app console di Windows C++. In alternativa, se è stato installato il supporto C++/CLI, è possibile creare un'app console CLR (.NET Framework).

Se si crea un'app console CLR, non è necessario apportare le modifiche seguenti alle impostazioni del compilatore e del debugger. Tuttavia, è necessario aggiungere #include "pch.h" all'inizio di ogni esempio.

In entrambi i casi, aggiungere a Project Properties>Linker>Input>Additional Dependencies( Dipendenze aggiuntive).comsuppw.lib

Se crei una nuova app console di Windows C++ per eseguire gli esempi, apportare le modifiche seguenti al progetto:

Aggiungere gli argomenti della /clr riga di comando e /Zc:twoPhase- alle proprietà>del progetto C++>Opzioni aggiuntive della riga di comando.>

L'opzione è in conflitto con alcune opzioni del /clr compilatore impostate quando si crea un progetto app console di Windows C++. I collegamenti seguenti forniscono istruzioni per la posizione in cui nell'IDE è possibile disattivare le opzioni in conflitto:

Disattiva (Imposta controlli di runtime di base su Impostazione predefinita): Proprietà>progetto C/C++>Code Generation>Basic Runtime Controlla>impostazione predefinita/RTC1
Disattiva /EHs (modello di gestione delle eccezioni): Proprietà>progetto C/C++>Generazione>codice Abilita eccezioni>C++ No
Exchange (formato informazioni di debug) per /Z7: Compatibile con Project Properties>C/C++>General>Debug Information Format>C7/Zi
Disattiva /JMC (debug just my code): le proprietà>del progetto C/C++>Supporto generale>sono solo il debug del>codice no
Impostare il tipo di debugger su mixed: Project Properties>Debugging>Debugger Type>Mixed (.NET Framework)
/ASSEMBLYDEBUGAttivare : Le proprietà>del progetto Linker Debugging>Debuggable>Assembly>Yes (ASSEMBLYDEBUG)

Esempio: Converti da `char *`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un char * oggetto ai tipi stringa elencati in precedenza. Una char * stringa (nota anche come stringa in stile C) usa un valore Null di terminazione per indicare la fine della stringa. Le stringhe di tipo C richiedono in genere 1 byte per carattere, ma possono anche usare 2 byte. Negli esempi seguenti, char * le stringhe vengono talvolta definite stringhe di caratteri multibyte a causa dei dati stringa risultanti dalla conversione da stringhe Unicode wide. Le funzioni carattere a byte singolo e multibyte (MBCS) possono operare su char * stringhe.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Esempio: Converti da `wchar_t *`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un wchar_t * oggetto a altri tipi di stringa. Diversi tipi di stringa, tra cui wchar_t *, implementano formati di caratteri wide. Per convertire una stringa tra un multibyte e un formato di caratteri wide, è possibile usare una singola chiamata di funzione come mbstowcs_s o una chiamata al costruttore per una classe come CStringA.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Esempio: Converti da `_bstr_t`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un _bstr_t oggetto a altri tipi di stringa. L'oggetto _bstr_t incapsula stringhe di caratteri BSTR wide. Una BSTR stringa ha un valore di lunghezza e non usa un carattere Null per terminare la stringa, ma il tipo stringa in cui si esegue la conversione può richiedere un carattere Null di terminazione.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Esempio: Converti da `CComBSTR`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un CComBSTR oggetto a altri tipi di stringa. Come _bstr_t, un CComBSTR oggetto incapsula stringhe di caratteri BSTR wide. Una BSTR stringa ha un valore di lunghezza e non usa un carattere Null per terminare la stringa, ma il tipo stringa in cui si esegue la conversione può richiedere un valore Null di terminazione.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Esempio: Converti da `CString`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un CString oggetto a altri tipi di stringa. CString è basato sul TCHAR tipo di dati, che a sua volta dipende dal fatto che il simbolo _UNICODE sia definito. Se non è definito, TCHAR viene definito come char e CString contiene una stringa di caratteri multibyte. Se _UNICODE _UNICODE è definito, TCHAR è definito come wchar_t e CString contiene una stringa di caratteri wide.

CStringA contiene il char tipo e supporta stringhe a byte singolo o multibyte. CStringW è la versione a caratteri wide. CStringA e CStringW non usare _UNICODE per determinare come devono essere compilati. CStringA e CStringW vengono usati in questo esempio per chiarire le piccole differenze nell'allocazione delle dimensioni del buffer e nella gestione dell'output.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Esempio: Converti da `basic_string`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un basic_string oggetto a altri tipi di stringa.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Esempio: Converti da `System::String`

Descrizione

In questo esempio viene illustrato come eseguire la conversione da un carattere wide System::String ad altri tipi di stringa.

Per informazioni sull'esecuzione e il debug di questo esempio, vedere Eseguire gli esempi.

Codice

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

Conversione tra stringhe strette e larghe

Le app C e Windows legacy usano tabelle codici anziché le codifiche Unicode quando si gestiscono stringhe strette e stringhe wide.

Le stringhe .NET sono UTF-16, ma ATL CStringA è una stringa stretta e la conversione da wide a narrow viene eseguita dalla WideCharToMultiByte funzione Win32. Quando si converte uno stile C (uno stile CHAR* CHAR* C è un .NET byte*) in una stringa, viene chiamata la funzione MultiByteToWideChar Win32 opposta.

Entrambe le funzioni si basano sul concetto di Windows di una tabella codici; non il concetto .NET di impostazioni cultura. Per modificare la tabella codici di sistema, usare l'impostazione dell'area usando Pannello di controllo> immettere Region nella casella >di ricerca Area (modificare le impostazioni locali del sistema di modifica data, ora o numero)>Impostazioni locali del sistema di modifica amministrativa.>

In una en-US versione del linguaggio di Windows, la tabella codici per impostazione predefinita è 1033. Se si installa una lingua diversa di Windows, la tabella codici sarà diversa. È possibile modificarlo usando il pannello di controllo.

C'è una mancata corrispondenza nel modo in cui CStringA esegue una conversione wide per restringere e il modo in cui gcnew string(CHAR*) viene eseguita una conversione stretta a larga. CStringApassa CP_THREAD_ACP, il che significa usare la tabella codici del thread corrente, al metodo di conversione di tipo narrowing. Ma string.ctor(sbyte*) passa CP_ACP, il che significa usare la tabella codici di sistema corrente, al metodo di conversione verso l'ampliamento. Se le tabelle codici di sistema e thread non corrispondono, può causare il danneggiamento dei dati di round trip.

Per riconciliare questa differenza, usare la costante _CONVERSION_DONT_USE_THREAD_LOCALE) per ottenere la conversione da usare CP_ACP (ad esempio .NET) anziché CP_THREAD_ACP. Per ulteriori informazioni, vedere _CONVERSION_DONT_USE_THREAD_LOCALE.

Un altro approccio consiste nell'usare pinvoke per chiamare GetThreadLocale. Usare l'oggetto restituito LCID per creare un oggetto CultureInfo. CultureInfo.TextInfo Usare quindi per ottenere la tabella codici da usare nella conversione.

Vedi anche

Macro di conversione di stringhe ATL e MFC
CString operazioni relative alle stringhe di tipo C
Procedura: convertire standard String in System::String
Procedura: eseguire la conversione System::String in standard String
Procedura: eseguire la conversione System::String in wchar_t* o char*
Programmazione con 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)

Condividi tramite

Procedura: Eseguire la conversione tra vari tipi di stringa

Eseguire gli esempi

Esempio: Converti da `char *`

Descrizione

Codice

Esempio: Converti da `wchar_t *`

Descrizione

Codice

Esempio: Converti da `_bstr_t`

Descrizione

Codice

Esempio: Converti da `CComBSTR`

Descrizione

Codice

Esempio: Converti da `CString`

Descrizione

Codice

Esempio: Converti da `basic_string`

Descrizione

Codice

Esempio: Converti da `System::String`

Descrizione

Codice

Conversione tra stringhe strette e larghe

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Procedura: Eseguire la conversione tra vari tipi di stringa

Eseguire gli esempi

Esempio: Converti da char *

Descrizione

Codice

Esempio: Converti da wchar_t *

Descrizione

Codice

Esempio: Converti da _bstr_t

Descrizione

Codice

Esempio: Converti da CComBSTR

Descrizione

Codice

Esempio: Converti da CString

Descrizione

Codice

Esempio: Converti da basic_string

Descrizione

Codice

Esempio: Converti da System::String

Descrizione

Codice

Conversione tra stringhe strette e larghe

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive

Esempio: Converti da `char *`

Esempio: Converti da `wchar_t *`

Esempio: Converti da `_bstr_t`

Esempio: Converti da `CComBSTR`

Esempio: Converti da `CString`

Esempio: Converti da `basic_string`

Esempio: Converti da `System::String`