Procédure : Effectuer une conversion entre différents types de chaînes

Article
10/12/2023

Cet article explique comment convertir différents types de chaînes Visual C++ en autres chaînes.

Les types de chaînes couverts incluent char *, , _bstr_twchar_t*, CComBSTR, CString, , basic_stringet System.String.

Dans tous les cas, une copie de la chaîne est effectuée lorsqu’elle est convertie en nouveau type. Les modifications apportées à la nouvelle chaîne n’affectent pas la chaîne d’origine, et inversement.

Pour plus d’informations sur la conversion de chaînes étroites et larges, consultez Conversion entre des chaînes étroites et des chaînes larges.

Exécuter les exemples

Pour exécuter les exemples dans Visual Studio 2022, vous pouvez créer une application console Windows C++. Ou, si vous avez installé la prise en charge de C++/CLI, vous pouvez créer une application console CLR (.NET Framework).

Si vous créez une application console CLR, vous n’avez pas besoin d’apporter les modifications suivantes aux paramètres du compilateur et du débogueur. Toutefois, vous devez ajouter #include "pch.h" en haut de chaque exemple.

Dans les deux cas, ajoutez-y les dépendances supplémentaires de l’éditeur>> de liens des propriétés>du projet.comsuppw.lib

Si vous créez une application console Windows C++ pour exécuter les exemples, apportez les modifications de projet suivantes :

Ajoutez les /clr arguments de ligne de commande aux /Zc:twoPhase- propriétés>du projet C++>Options supplémentaires sur la ligne>de commande.

Le /clr commutateur est en conflit avec certains commutateurs du compilateur définis lorsque vous créez un projet d’application console Windows C++. Les liens suivants fournissent des instructions pour savoir où, dans l’IDE, vous pouvez désactiver les commutateurs en conflit :

/RTC1 Désactiver (Définir les vérifications du runtime de base sur la valeur par défaut) : Propriétés>du projet C/C++>Code Generation>Basic Runtime Checks Default>
Désactiver (modèle de gestion des exceptions) : Propriétés>du projet C/C++>Génération>de code Activer les exceptions>C++ Non/EHs
Exchange /Zi (format d’informations de débogage) pour /Z7: Compatible avec les propriétés>du projet C/C++>Format>d’informations de débogage général>C7
/JMC Désactiver (juste mon débogage de code) : Propriétés>du projet C/C++>Prise en charge générale>uniquement de mon débogage>de code non
Définissez le type de débogueur sur mixte : Type de débogueur>de débogage>des propriétés>du projet mixte (.NET Framework)
Activer : Project properties>Linker>Debugging>Debuggable Assembly>Yes (ASSEMBLYDEBUG) /ASSEMBLYDEBUG

Exemple : Convertir à partir de `char *`

Description

Cet exemple montre comment effectuer une conversion d’un char * type de chaîne en types de chaînes répertoriés ci-dessus. Une char * chaîne (également appelée chaîne de style C) utilise une valeur Null de fin pour indiquer la fin de la chaîne. Les chaînes de style C nécessitent généralement 1 octet par caractère, mais peuvent également utiliser 2 octets. Dans les exemples ci-dessous, char * les chaînes sont parfois appelées chaînes de caractères multioctets en raison des données de chaîne résultant de la conversion à partir de chaînes Unicode larges. Les fonctions caractères à octets uniques et multioctets (MBCS) peuvent fonctionner sur char * des chaînes.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Exemple : Convertir à partir de `wchar_t *`

Description

Cet exemple montre comment effectuer une conversion d’un wchar_t * vers d’autres types de chaînes. Plusieurs types de chaînes, notamment wchar_t *, implémentent des formats de caractères larges. Pour convertir une chaîne entre un multioctet et un format de caractère large, vous pouvez utiliser un appel de fonction unique comme mbstowcs_s ou un appel de constructeur pour une classe comme CStringA.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Exemple : Convertir à partir de `_bstr_t`

Description

Cet exemple montre comment effectuer une conversion d’un _bstr_t vers d’autres types de chaînes. L’objet _bstr_t encapsule des chaînes de caractères BSTR larges. Une BSTR chaîne a une valeur de longueur et n’utilise pas de caractère Null pour mettre fin à la chaîne, mais le type de chaîne que vous convertissez peut nécessiter un caractère null de fin.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Exemple : Convertir à partir de `CComBSTR`

Description

Cet exemple montre comment effectuer une conversion d’un CComBSTR vers d’autres types de chaînes. Comme _bstr_t, un CComBSTR objet encapsule des chaînes de caractères BSTR larges. Une BSTR chaîne a une valeur de longueur et n’utilise pas de caractère Null pour arrêter la chaîne, mais le type de chaîne que vous convertissez peut nécessiter une valeur Null de fin.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Exemple : Convertir à partir de `CString`

Description

Cet exemple montre comment effectuer une conversion d’un CString vers d’autres types de chaînes. CString est basé sur le TCHAR type de données, qui à son tour dépend de la définition du symbole _UNICODE . S’il _UNICODE n’est pas défini, TCHAR est défini pour être char et CString contient une chaîne de caractères multioctets ; si _UNICODE elle est définie, TCHAR est définie pour être wchar_t et CString contient une chaîne de caractères large.

CStringA contient le char type et prend en charge les chaînes à octets uniques ou multioctets. CStringW est la version de caractère large. CStringA et CStringW n’utilisez _UNICODE pas pour déterminer comment ils doivent être compilés. CStringA et CStringW sont utilisés dans cet exemple pour clarifier les différences mineures dans l’allocation de taille de mémoire tampon et la gestion des sorties.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Exemple : Convertir à partir de `basic_string`

Description

Cet exemple montre comment effectuer une conversion d’un basic_string vers d’autres types de chaînes.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Exemple : Convertir à partir de `System::String`

Description

Cet exemple montre comment convertir un caractère large System ::String en d’autres types de chaînes.

Pour plus d’informations sur l’exécution et le débogage de cet exemple, consultez Exécuter les exemples.

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)

Conversion entre chaînes étroites et larges

Les applications C et Windows héritées utilisent des pages de code plutôt que des encodages Unicode lors de la gestion de chaînes étroites et de chaînes larges.

Les chaînes .NET sont UTF-16, mais ATL CStringA est une chaîne étroite, et la conversion de large en étroite est effectuée par la WideCharToMultiByte fonction Win32. Lors de la conversion d’un style CHAR* C (un style CHAR* C est un .NET byte*) en chaîne, la fonction Win32 opposée est MultiByteToWideChar appelée.

Les deux fonctions s’appuient sur le concept Windows d’une page de codes ; pas le concept .NET d’une culture. Pour modifier la page de codes système, utilisez le paramètre de région à l’aide de Panneau de configuration> entrer Region dans la zone >de recherche Région (modifier la date, l’heure ou les formats de nombre)Paramètres> régionaux système de modification administrative.>

Sur une en-US version linguistique de Windows, la page de codes est par défaut 1033. Si vous installez une autre langue de Windows, elle aura une page de codes différente. Vous pouvez le modifier à l’aide du panneau de configuration.

Il existe une incompatibilité de la façon d’effectuer CStringA une conversion large à étroite et de la façon d’effectuer gcnew string(CHAR*) une conversion étroite à large. CStringApasse CP_THREAD_ACP, ce qui signifie utiliser la page de codes du thread actuel, à la méthode de conversion étroite. Mais string.ctor(sbyte*) passe CP_ACP, ce qui signifie utiliser la page de codes système actuelle, à la méthode de conversion étendue. Si les pages de code système et thread ne correspondent pas, cela peut entraîner une altération des données aller-retour.

Pour rapprocher cette différence, utilisez la constante _CONVERSION_DONT_USE_THREAD_LOCALE) pour obtenir la conversion à utiliser CP_ACP (comme .NET) au lieu de CP_THREAD_ACP. Pour plus d’informations, consultez _CONVERSION_DONT_USE_THREAD_LOCALE.

Une autre approche consiste à utiliser pinvoke pour appeler GetThreadLocale. Utilisez le retour LCID pour créer un CultureInfo. CultureInfo.TextInfo Utilisez ensuite pour obtenir la page de codes à utiliser dans la conversion.

Voir aussi

Macros de conversion de chaînes ATL et MFC
CString opérations relatives aux chaînes de style C
Guide pratique pour convertir la norme String en System::String
Procédure : convertir System::String en standard String
Procédure : convertir System::String en wchar_t* ou char*
Programmation avec 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)

Partager via

Procédure : Effectuer une conversion entre différents types de chaînes

Exécuter les exemples

Exemple : Convertir à partir de `char *`

Description

Code

Exemple : Convertir à partir de `wchar_t *`

Description

Code

Exemple : Convertir à partir de `_bstr_t`

Description

Code

Exemple : Convertir à partir de `CComBSTR`

Description

Code

Exemple : Convertir à partir de `CString`

Description

Code

Exemple : Convertir à partir de `basic_string`

Description

Code

Exemple : Convertir à partir de `System::String`

Description

Code

Conversion entre chaînes étroites et larges

Voir aussi

Commentaires

Ressources supplémentaires

Partager via

Procédure : Effectuer une conversion entre différents types de chaînes

Exécuter les exemples

Exemple : Convertir à partir de char *

Description

Code

Exemple : Convertir à partir de wchar_t *

Description

Code

Exemple : Convertir à partir de _bstr_t

Description

Code

Exemple : Convertir à partir de CComBSTR

Description

Code

Exemple : Convertir à partir de CString

Description

Code

Exemple : Convertir à partir de basic_string

Description

Code

Exemple : Convertir à partir de System::String

Description

Code

Conversion entre chaînes étroites et larges

Voir aussi

Commentaires

Ressources supplémentaires

Exemple : Convertir à partir de `char *`

Exemple : Convertir à partir de `wchar_t *`

Exemple : Convertir à partir de `_bstr_t`

Exemple : Convertir à partir de `CComBSTR`

Exemple : Convertir à partir de `CString`

Exemple : Convertir à partir de `basic_string`

Exemple : Convertir à partir de `System::String`