Macros de conversión de cadena ATL y MFC
TOC
Collapse the table of content
Expand the table of content
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Macros de conversión de cadena ATL y MFC

Las macros de conversión de cadena que se describen aquí son válidas para ATL y MFC. Para obtener más información sobre la conversión de cadenas de MFC, vea TN059: Mediante macros de conversión de MFC mbcs/unicode y Macros y funciones globales de MFC.

ATL 7,0 presenta nuevas clases y macros de conversión, proporcionando mejoras significativas en las macros existentes.

Los nombres de las nuevas clases y macros de conversión de cadena adoptan la forma:

C SourceType 2[C]DestinationType[EX]

donde:

  • SourceType y DestinationType se describen en la tabla siguiente.

  • [C] es el presente cuando el tipo de destino debe ser constante.

  • [EX] es el presente cuando el tamaño inicial del búfer se debe especificar como argumento de plantilla.

    SourceType/DestinationType

    Descripción

    a

    cadena de caracteres ANSI.

    W

    Cadena de caracteres Unicode.

    T

    Cadena de caracteres genérica (equivalente a la w cuando _UNICODE está definido, equivalente a otro).

    OLE

    Cadena de caracteres OLE (equivalente a T).

Por ejemplo, convertir una cadena Unicode en una cadena genérica sin cambiar la cadena convertida, utilice CW2 CT.

Si se sabe que la cadena convertida es improbable que ser más de 64 caracteres, la versión de EX , como CW2 CTEX<64>, se puede utilizar para ahorrar espacio en la pila.

Nota Nota

La manera recomendada de convertir a y de las cadenas BSTR es utilizar la clase de CComBSTR . Para convertir un BSTR, pase la cadena existente al constructor de CComBSTR. Para convertir un BSTR, utilice COLE2[C]DestinationType[EX], por ejemplo T OF COLE2.

Las nuevas clases de conversión que requieren un uso del búfer (CA2AEX, CA2WEX, CW2AEX, y CW2WEX) un buffer estático de tamaño fijo de almacenar el resultado de la conversión. Si el resultado es demasiado grande ajustarse al buffer estático, la clase asigna memoria mediante malloc, libera la memoria cuando el objeto salga del ámbito. Esto garantiza que, a diferencia de las macros de conversión de texto, estas clases son seguras de utilizar en bucles y no desborden la pila.

Las macros de conversión introducidas en ATL 7,0 se optimizan para ser conscientes de cadenas nulas de entrada. Estas macros devolverán NULL si el parámetro de entrada es NULL sin asignar ninguna memoria.

De forma predeterminada, las clases de conversión ATL y las macros utilizarán la página de códigos ANSI actual del subproceso para la conversión. Si desea reemplazar que el comportamiento de una conversión específica mediante macros basadas en las clases CA2WEX o CW2AEX, especifique la página de códigos como segundo parámetro al constructor para la clase.

Nota de seguridad Nota sobre la seguridad

Compruebe la longitud de las cadenas antes de pasarlas a estas macros para evitar posibles problemas de saturación del búfer. Los desbordamientos de pila son excepciones que también se podrían detectar con try/excepto.

Hay varias diferencias importantes entre las macros de conversión de cadena y las nuevas clases de conversión de cadena:

Las macros de conversión de ATL 3,0

Nuevas clases de conversión ATL 7,0

Asigna memoria en la pila.

Utiliza la memoria de la pila para las cadenas pequeñas. Utiliza la pila si la pila no es suficientemente grande.

Se libera la cadena cuando se sale de la función.

Se libera la cadena cuando la variable sale del ámbito.

No se puede utilizar en los controladores de excepciones.

Se puede utilizar en los controladores de excepciones.

No apto para utilizarlo en bucles. El uso de memoria crece hasta que se salga de la función.

Admite el uso de bucles. El ámbito del bucle garantiza que se libera esa memoria en cada iteración.

No ofrecen para cadenas grandes. se limita el espacio de pila.

Sin problemas con cadenas grandes. Las cadenas se asignadas en la pila.

Requiere normalmente USES_CONVERSION definir.

Nunca requiere USES_CONVERSION definir.

el significado de OLE depende de la definición de OLE2ANSI.

OLE siempre es equivalente a la hora.

87zae4a3.collapse_all(es-es,VS.110).gifCódigo


//Example 1
// Convert LPCWSTR to LPCSTR.
void ExampleFunction1(LPCWSTR pszW)
{
   // Create an instance of CW2A, called pszA,
   // and initialize it with pszW.
   CW2A pszA(pszW);
   // pszA works like an LPCSTR, and can be used thus:
   ExampleFunctionA(pszA);  
   // Note: pszA will become invalid when it goes out of scope.
}

// Example 2
// Use a temporary instance of CW2A.
void ExampleFunction2(LPCWSTR pszW)
{
   // Create a temporary instance of CW2A,
   // and initialize it with pszW.
   ExampleFunctionA(CW2A(pszW));
   // Note: the temporary instance becomes invalid 
   // after the execution of the statement above.
}

// Example 3
// Incorrect use of conversion macros.
void ExampleFunction3(LPCWSTR pszW)
{
   // Create a temporary instance of CW2A,
   // save a pointer to it and then delete
   // the temportary instance.
   LPCSTR pszA = CW2A(pszW);
   // The pszA in the following line is an invalid pointer,
   // as the instance of CW2A has gone out of scope.
   ExampleFunctionA(pszA);
}


87zae4a3.collapse_all(es-es,VS.110).gifUna advertencia con respecto a las instancias de clase temporales

Debe ser subrayado que a continuación no resulta código:


LPCTSTR szr = CA2T(szReplaceFile);


Realizar con ATL 3,0, era aceptable utilizar:


LPCTSTR szr = A2T(szReplaceFile);   


como la memoria asignada por las funciones de conversión no se libera hasta que la función actual fuera salida. el mismo código no funciona con las nuevas clases.

este código:


LPCTSTR szr = CA2T(szReplaceFile);   


equivale a:


LPCTSTR szr;
{
   CA2T temp(szReplaceFile);
   szr = temp.operator LPTSTR();
}   


Como la memoria asignada por el objeto temporal y devuelto del operador de conversión se destruye cuando se destruye el objeto temporal, utilizando el valor de szr tendrá resultados no deseados.

En su lugar, use este código:


CA2T szr(szReplaceFile);   


El operador de conversión hace que el objeto de t CA2 es LPCTSTR.

87zae4a3.collapse_all(es-es,VS.110).gifuso avanzado

El tamaño de búfer estático predeterminado es de 128 caracteres. Si el tamaño de búfer debe cambiarse para una conversión específica, utilice la EX versión de una macro, y especifique el tamaño de búfer como argumento de plantilla.


// Example 4
// Changing the size of the buffer.
void ExampleFunction4(LPCWSTR pszW)
{
   // Use a 16-character buffer.
   ExampleFunctionA(CW2AEX<16>(pszW));
}


A continuación se muestra un ejemplo de especificar la página de códigos como segundo parámetro al constructor para la clase.


// Example 5
// Specifying the code page.
void ExampleFunction5(LPCWSTR pszW)
{
   // Convert to the Macintosh code page
   ExampleFunctionA(CW2A(pszW, CP_MACCP));
}


Las macros de conversión de texto original todavía están disponibles y se muestran en la tabla siguiente:

Macros de conversión de cadena ATL 3,0

A2BSTR

OLE2A

T2A

W2A

A2COLE

OLE2BSTR

T2BSTR

W2BSTR

A2CT

OLE2CA

T2CA (desusada. Uso T2CA_EX o CT2CA en su lugar.)

W2CA

A2CW

OLE2CT

T2COLE

W2COLE

A2OLE

OLE2CW

T2CW

W2CT

A2T

OLE2T

T2OLE

W2OLE

A2W

OLE2W

T2W

W2T

La sintaxis para utilizar estas macros es la siguiente:

MACRONAME( string_address )

Por ejemplo:


A2W(lpa);


En los nombres de macro, el tipo string de origen está a la izquierda (por ejemplo, para) y el tipo string de destino está a la derecha (por ejemplo, w). a representa LPSTR, OLE representa LPOLESTR, T representa LPTSTR, y w representa LPWSTR.

Si hay C. en el nombre de la macro, la macro se convierte en const una cadena. por ejemplo, W2CA convierte LPWSTR a LPCSTR.

Así, A2W convierte LPSTR a LPWSTR, OLE2T convierte LPOLESTR a LPTSTR, etc.

El comportamiento de las macros de conversión de cadena ATL depende de la directiva del compilador en efecto, si existe. Si el origen y de destino son iguales, ninguna conversión tiene lugar. Cambio T y OLE de las directivas de compilador como sigue:

Directiva del compilador en efecto

T se convierte

OLE se convierte

NONE

a

W

_UNICODE

W

W

OLE2ANSI

a

a

_UNICODE y OLE2ANSI

W

a

La cadena de destino se crea con _alloca, excepto cuando el tipo de destino es BSTR. Mediante _alloca asigna memoria del montón, para cuando finaliza la función, automáticamente limpiarla. De forma predeterminada esta macro sólo convertirá hasta 500KB al mismo tiempo.

Al utilizar una macro de la conversión de cadenas ATL, especifique la macro de USES_CONVERSION al principio de la función para evitar errores del compilador. Por ejemplo:


void StringFunc(LPSTR lpsz)
{
   USES_CONVERSION;

   LPWSTR x = A2W(lpsz);
   // Do something with x
   wprintf_s(L"x is %s", x);
}


87zae4a3.collapse_all(es-es,VS.110).gifRequisitos

archivo de encabezado: AtlBase.h, AtlConv.h (declarado en AtlConv.h)

Adiciones de comunidad

AGREGAR
Mostrar:
© 2016 Microsoft