Nasıl yapılır: Çeşitli dize türleri arasında dönüştürme

Bu makalede çeşitli Visual C++ dize türlerinin diğer dizelere nasıl dönüştürüldüğü gösterilmektedir.

Kapsanan dize türleri , , char *, wchar_t*, _bstr_t, CComBSTR, CStringve basic_stringdeğerlerini içerirSystem.String.

Her durumda, yeni türe dönüştürüldüğünde dizenin bir kopyası oluşturulur. Yeni dizede yapılan değişiklikler özgün dizeyi etkilemez ve tam tersi de geçerlidir.

Dar ve geniş dizeleri dönüştürme hakkında daha fazla arka plan bilgisi için bkz . Dar dizeler ve geniş dizeler arasında dönüştürme.

Örnekleri çalıştırma

Visual Studio 2022'de örnekleri çalıştırmak için yeni bir C++ Windows Konsol Uygulaması oluşturabilirsiniz. C++/CLI desteğini yüklediyseniz bir CLR Konsol Uygulaması (.NET Framework) oluşturabilirsiniz.

CLR Konsol Uygulaması oluşturursanız, derleyici ve hata ayıklayıcı ayarlarında aşağıdaki değişiklikleri yapmanız gerekmez. Ancak, her örneğin en üstüne eklemeniz #include "pch.h" gerekir.

Her iki durumda da Proje Özelliklericomsuppw.lib ekleyin.>

Örnekleri çalıştırmak için yeni bir C++ Windows Konsolu uygulaması oluşturursanız aşağıdaki proje değişikliklerini yapın:

/clr Proje Özellikleri/Zc:twoPhase-C++>Komut Satırı Ek Seçenekleri'ne ve > komut satırı>bağımsız değişkenlerini ekleyin.

Anahtar, /clr C++ Windows Konsol Uygulaması projesi oluşturduğunuzda ayarlanan bazı derleyici anahtarlarıyla çakıştırılır. Aşağıdaki bağlantılar, IDE'de çakışan anahtarları nerede kapatabileceğinize ilişkin yönergeler sağlar:

Kapat (Temel Çalışma Zamanı Denetimlerini Varsayılan Olarak Ayarla): Proje Özellikleri/RTC1C/C++>Temel Çalışma Zamanı Denetimleri Varsayılan>>
Kapat (Özel durum işleme modeli): /EHsC/C++>Kod Oluşturma>C++ Özel Durumlarını>Etkinleştir Hayır >
için Exchange /Zi : /Z7
Kapat (Yalnızca Kod hata ayıklamam)/JMC
Hata ayıklayıcı türünü karma olarak ayarlayın: >
/ASSEMBLYDEBUGAç: >>

Örnek: Dönüştürme `char *`

Açıklama

Bu örnekte, bir'den char * yukarıda listelenen dize türlerine nasıl dönüştürüldüğü gösterilmektedir. Dize char * (C stili dize olarak da bilinir), dizenin sonunu belirtmek için sonlandırıcı null kullanır. C stili dizeler genellikle karakter başına 1 bayt gerektirir, ancak 2 bayt da kullanabilir. Aşağıdaki örneklerde, char * geniş Unicode dizelerinden dönüştürülen dize verileri nedeniyle dizeler bazen çok baytlı karakter dizeleri olarak adlandırılır. Tek baytlı ve çok baytlı karakter (MBCS) işlevleri dizelerde çalışabilir char * .

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Örnek: Dönüştürme `wchar_t *`

Açıklama

Bu örnekte, bir wchar_t * dizeden diğer dize türlerine dönüştürme gösterilmektedir. dahil olmak üzere wchar_t *çeşitli dize türleri geniş karakter biçimleri uygular. Dizeyi çok baytlı ve geniş karakter biçimi arasında dönüştürmek için gibi tek bir işlev çağrısı veya gibi mbstowcs_sCStringAbir sınıf için oluşturucu çağırma kullanabilirsiniz.

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Örnek: Dönüştürme `_bstr_t`

Açıklama

Bu örnekte, bir _bstr_t dizeden diğer dize türlerine dönüştürme gösterilmektedir. _bstr_t Nesnesi geniş karakter BSTR dizelerini kapsüller. Dizenin BSTR uzunluk değeri vardır ve dizeyi sonlandırmak için null karakter kullanmaz, ancak dönüştürdüğünüz dize türü sonlandırıcı bir null karakter gerektirebilir.

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Örnek: Dönüştürme `CComBSTR`

Açıklama

Bu örnekte, bir CComBSTR dizeden diğer dize türlerine dönüştürme gösterilmektedir. gibi _bstr_tbir CComBSTR nesne de geniş karakter BSTR dizelerini kapsüller. Dizenin BSTR uzunluk değeri vardır ve dizeyi sonlandırmak için null karakter kullanmaz, ancak dönüştürdüğünüz dize türü için sonlandırıcı null gerekebilir.

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Örnek: Dönüştürme `CString`

Açıklama

Bu örnekte, bir CString dizeden diğer dize türlerine dönüştürme gösterilmektedir. CString veri türünü temel alır TCHAR ve bu da simgenin _UNICODE tanımlanıp tanımlanmadığına bağlıdır. Tanımlanmamışsa, olmak üzere tanımlanır ve _UNICODE çok baytlı bir karakter dizesi içerir; tanımlanmışsaTCHAR, char olmak CString üzere tanımlanır ve _UNICODE geniş bir karakter dizesi içerir.TCHARwchar_tCString

CStringA char türünü içerir ve tek baytlı veya çok baytlı dizeleri destekler. CStringW geniş karakter sürümüdür. CStringA ve CStringW nasıl derlenmeleri gerektiğini belirlemek için kullanmayın _UNICODE . CStringA ve CStringW arabellek boyutu ayırma ve çıkış işleme arasındaki küçük farkları netleştirmek için bu örnekte kullanılır.

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Örnek: Dönüştürme `basic_string`

Açıklama

Bu örnekte, bir basic_string dizeden diğer dize türlerine dönüştürme gösterilmektedir.

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Örnek: Dönüştürme `System::String`

Açıklama

Bu örnekte, geniş bir system::String karakterinden diğer dize türlerine nasıl dönüştürüldüğü gösterilmektedir.

Bu örneği çalıştırma ve hata ayıklama hakkında bilgi için bkz . Örnekleri çalıştırma.

Kod

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

Dar ve geniş dizeler arasında dönüştürme

Eski C ve Windows uygulamaları, dar dizeleri ve geniş dizeleri işlerken Unicode kodlamaları yerine kod sayfaları kullanır.

.NET dizeleri UTF-16'dır, ancak ATL'ler CStringA dar bir dizedir ve genişten dara dönüştürme Win32 işlevi tarafından WideCharToMultiByte gerçekleştirilir. C stili CHAR* (C stili CHAR* bir .NET byte*) dizeye dönüştürülürken, win32 işlevinin MultiByteToWideChar tersi çağrılır.

Her iki işlev de bir kod sayfasının Windows kavramına dayanır; bir kültürün .NET kavramı değildir. Sistem kodu sayfasını değiştirmek için bölge ayarını kullanarak bölge ayarını kullanın Denetim Masası>Region arama kutusuna>Sistem yerel ayarını değiştirin.

en-US Windows'un dil sürümünde kod sayfası varsayılan olarak 1033'tür. Farklı bir Windows dili yüklerseniz, farklı bir kod sayfası olur. Denetim masasını kullanarak değiştirebilirsiniz.

Geniş ve dar bir dönüştürme ve dar ve geniş dönüştürme gerçekleştirme yönteminde CStringA bir uyuşmazlık gcnew string(CHAR*) vardır. CStringA CP_THREAD_ACPgeçerli iş parçacığı kodu sayfasını kullanmak anlamına gelen öğesini daraltma dönüştürme yöntemine geçirir. Ancakstring.ctor(sbyte*), geçerli CP_ACP kodu sayfasını kullanmak için genişletme dönüştürme yöntemine iletir. Sistem ve iş parçacığı kodu sayfaları eşleşmiyorsa, gidiş dönüş veri bozulmasına neden olabilir.

Bu farkı mutabık hale getirmek için sabitini _CONVERSION_DONT_USE_THREAD_LOCALEkullanın) ve dönüştürmenin yerine (.NET gibi) CP_ACPkullanılmasını CP_THREAD_ACP sağlayın. Daha fazla bilgi için bkz. _CONVERSION_DONT_USE_THREAD_LOCALE.

Başka bir yaklaşım da çağrısı pinvokeyapmak için kullanmaktırGetThreadLocale. Döndürülen LCID öğesini kullanarak bir CultureInfooluşturun. Ardından, dönüştürmede kullanılacak kod sayfasını almak için kullanın CultureInfo.TextInfo .

Ayrıca bkz.

ATL ve MFC dize dönüştürme makroları
CString C stili dizelerle ilgili işlemler
Nasıl yapılır: standart String olarak dönüştürme System::String
Nasıl yapılır: standarda dönüştürme System::StringString
Nasıl yapılır: veya'ya System::String dönüştürme wchar_t*char*
ile programlama 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)

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Nasıl yapılır: Çeşitli dize türleri arasında dönüştürme

Örnekleri çalıştırma

Örnek: Dönüştürme char *

Açıklama

Kod

Örnek: Dönüştürme wchar_t *

Açıklama

Kod

Örnek: Dönüştürme _bstr_t

Açıklama

Kod

Örnek: Dönüştürme CComBSTR

Açıklama

Kod

Örnek: Dönüştürme CString

Açıklama

Kod

Örnek: Dönüştürme basic_string

Açıklama

Kod

Örnek: Dönüştürme System::String

Açıklama

Kod

Dar ve geniş dizeler arasında dönüştürme

Ayrıca bkz.

Geri Bildirim

Ek kaynaklar

Örnek: Dönüştürme `char *`

Örnek: Dönüştürme `wchar_t *`

Örnek: Dönüştürme `_bstr_t`

Örnek: Dönüştürme `CComBSTR`

Örnek: Dönüştürme `CString`

Örnek: Dönüştürme `basic_string`

Örnek: Dönüştürme `System::String`