Procedimiento Convertir entre distintos tipos de cadenas
En este artículo se muestra cómo convertir distintos tipos de cadenas de Visual C++ en otras cadenas.
Los tipos de cadenas que se tratan incluyen char *, wchar_t*, _bstr_t, CComBSTR, CString, basic_string y System.String.
En todos los casos, se realiza una copia de la cadena cuando se convierte en el nuevo tipo. Los cambios realizados en la nueva cadena no afectan a la cadena original, y viceversa.
Para obtener más información sobre la conversión de cadenas estrechas y anchas, vea Conversión entre cadenas estrechas y anchas.
Ejecución de los ejemplos
Para ejecutar los ejemplos en Visual Studio 2022, puede crear una nueva aplicación de consola de Windows de C++. O bien, si ha instalado compatibilidad con C++/CLI, puede crear una aplicación de consola CLR (.NET Framework).
Si crea una aplicación de consola CLR, no tiene que realizar los siguientes cambios en la configuración del compilador y el depurador. Pero tiene que agregar #include "pch.h" al principio de cada ejemplo.
En cualquier caso, agregue comsuppw.lib a Propiedades del proyecto>Enlazador>Entrada>Dependencias adicionales.
Si crea una nueva aplicación de consola de Windows de C++ para ejecutar los ejemplos, realice los siguientes cambios en el proyecto:
- Agregue los argumentos de la línea de comandos
/clry/Zc:twoPhase-a Propiedades del proyecto>C++>Línea de comandos>Opciones adicionales.
El modificador /clr entra en conflicto con algunos modificadores del compilador que se establecen al crear un proyecto de aplicación de consola de Windows de C++. Los vínculos siguientes proporcionan instrucciones sobre dónde en el IDE se pueden desactivar los modificadores en conflicto:
/RTC1Desactivar (establecer comprobaciones básicas en tiempo de ejecución en valor predeterminado): propiedades>del proyecto C/C++>Code Generation>Basic Runtime Checks Default>/EHsDesactivar (modelo de control de excepciones):Propiedades>del proyecto C/C++>Generación>de código Habilitar excepciones de>C++ No- Exchange
/Zi(formato de información de depuración) para/Z7: Propiedades>del proyecto C/C++>General>Debug Information Format>C7 compatible - Desactivar (solo mi depuración de código):Propiedades>del proyecto C/C++>Compatibilidad general>solo con la depuración de>mi código no
/JMC - Establecer el tipo del depurador en mixto: Propiedades del proyecto>Depuración>Tipo de depurador>Mixto (.NET Framework)
/ASSEMBLYDEBUGActivar : Propiedades>del proyecto Enlazador>Depuración>del ensamblado>depurable Sí (ASSEMBLYDEBUG)
Ejemplo: Conversión de char *
Descripción
En este ejemplo se muestra cómo convertir de char * a los tipos de cadena enumerados anteriormente. Una cadena char * (también conocida como cadena de estilo C) usa un valor null de terminación para indicar el final de la cadena. Normalmente, las cadenas de estilo C requieren 1 byte por carácter, pero también pueden usar 2. En los ejemplos siguientes a veces se hace referencia a las cadenas char * como cadenas de caracteres multibyte debido a los datos de cadena que resultan de la conversión de cadenas Unicode anchas. Las funciones de un solo byte y de caracteres multibyte (MBCS) pueden funcionar en cadenas char *.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Ejemplo: Conversión de wchar_t *
Descripción
En este ejemplo se muestra cómo convertir de wchar_t * a otros tipos de cadena. Varios tipos de cadena, incluido wchar_t *, implementan formatos de carácter ancho. Para convertir una cadena entre un multibyte y un formato de carácter ancho, puede usar una sola llamada de función, como mbstowcs_s, o una invocación de constructor para una clase como CStringA.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Ejemplo: Conversión de _bstr_t
Descripción
En este ejemplo se muestra cómo convertir de _bstr_t a otros tipos de cadena. El objeto _bstr_t encapsula cadenas BSTR de carácter ancho. Una cadena BSTR tiene un valor de longitud y no usa un carácter nulo para finalizar la cadena, aunque el tipo de cadena que se convierte puede requerir un carácter nulo de terminación.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Ejemplo: Conversión de CComBSTR
Descripción
En este ejemplo se muestra cómo convertir de CComBSTR a otros tipos de cadena. Igual que _bstr_t, un objeto CComBSTR encapsula cadenas BSTR de carácter ancho. Una cadena BSTR tiene un valor de longitud y no usa un carácter nulo para finalizar la cadena, aunque el tipo de cadena que se convierte puede requerir un carácter nulo de terminación.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Ejemplo: Conversión de CString
Descripción
En este ejemplo se muestra cómo convertir de CString a otros tipos de cadena. CString se basa en el tipo de datos TCHAR que, a su vez, depende de si se ha definido el símbolo _UNICODE. Si _UNICODE no se ha definido, TCHAR se define como char y CString contiene una cadena de caracteres multibyte; si _UNICODE se ha definido, TCHAR se define como wchar_t y CString contiene una cadena de carácter ancho.
CStringA contiene el tipo char y admite cadenas de un solo byte o multibyte. CStringW es la versión de carácter ancho. CStringA y CStringW no usan _UNICODE para determinar cómo se deben compilar. CStringA y CStringW se usan en este ejemplo para aclarar pequeñas diferencias en la asignación de tamaño de búfer y el control de resultados.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Ejemplo: Conversión de basic_string
Descripción
En este ejemplo se muestra cómo convertir de basic_string a otros tipos de cadena.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Ejemplo: Conversión de System::String
Descripción
En este ejemplo se muestra cómo convertir de un carácter ancho System::String a otros tipos de cadena.
Para obtener información sobre cómo ejecutar y depurar este ejemplo, vea Ejecución de los ejemplos.
Código
// 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)
Conversión entre cadenas estrechas y anchas
Las aplicaciones heredadas de C y Windows usan páginas de códigos en lugar de codificaciones Unicode a la hora de controlar cadenas estrechas y anchas.
Las cadenas de .NET son UTF-16, pero CStringA de ATL es una cadena estrecha, y la conversión de ancha a estrecha se realiza mediante la función WideCharToMultiByte de Win32. Al convertir CHAR* de estilo C (CHAR* de estilo C es byte* de NET) en una cadena, se llama a la función opuesta de Win32, MultiByteToWideChar.
Ambas funciones se basan en el concepto de Windows de página de códigos, no el concepto de .NET de referencia cultural. Para cambiar la página de códigos del sistema, use la configuración de región mediante Panel de control> escriba Region en el cuadro de búsqueda >Región (cambiar formatos de fecha, hora o número)>Administrativo>Cambiar la configuración regional del sistema.
En una versión de idioma en-US de Windows, la página de códigos tiene como valor predeterminado 1033. Si instala un idioma diferente de Windows tendrá una página de códigos distinta. Puede cambiarlo mediante el Panel de control.
Hay una discrepancia en la forma en que CStringA realiza una conversión entre ancho y estrecho y la forma en que lo hace gcnew string(CHAR*). CStringA pasa CP_THREAD_ACP, lo que significa usar la página de códigos del subprocesoactual, al método de conversión de restricción. Pero string.ctor(sbyte*) pasa CP_ACP, lo que significa usar la página de códigos del sistema actual, al método de conversión de ampliación. Si las páginas de códigos del sistema y del subproceso no coinciden, puede provocar daños en los datos de ida y vuelta.
Para conciliar esta diferencia, use la constante _CONVERSION_DONT_USE_THREAD_LOCALE) para obtener la conversión para usar CP_ACP (como .NET) en lugar de CP_THREAD_ACP. Para obtener más información, vea _CONVERSION_DONT_USE_THREAD_LOCALE.
Otro enfoque es usar pinvoke para llamar a GetThreadLocale. Use el elemento LCID devuelto para crear CultureInfo. Después, use CultureInfo.TextInfo para obtener la página de códigos que se usará en la conversión.
Consulte también
Macros de conversión de cadenas ATL y MFC
CString Operaciones relacionadas con cadenas de estilo C
Cómo: Convertir cadenas estándar String en System::String
Cómo: Convertir System::String en cadenas estándar String
Procedimiento Convertir System::String en wchar_t* o char*
Programar 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)
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de