Acerca del problema de convertir datos de tipo char sin firmar a decimal o hexadecimal
Confundido, este artículo presentará el uso de algunos tipos de datos comunes.
Primero definamos algunos tipos comunes de variables para ilustrar
int i = 100;
long l = 2001
float. f= 300.2;
doble d=12345.119;
char nombre de usuario[]="Cheng Peijun"
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2
1. Convertir otros tipos de datos; a cadenas
Tipo entero corto (int)
itoa(i,temp,10);///Convierte i en una cadena y ponlo en temp, el último número representa decimal
itoa(i,temp,2); /// Convertir en modo binario
Entero largo (largo)
ltoa(l,temp,10) ;
Número de coma flotante (flotante, doble)
Utilice fcvt para completar la conversión. Este es un ejemplo en MSDN:
int decimal, sign <. /p>
char *buffer;
doble fuente = 3.1415926535;
buffer = _fcvt( fuente, 7, &decimal, &sign ); resultado: fuente: 3.1415926535 buffer: '31415927' decimal: 1 signo: 0
decimal representa la posición del punto decimal, signo representa el signo: 0 es un número positivo, 1 es un número negativo
CString variable
str = "Juegos Olímpicos de Beijing 2008"
buf = (LPSTR)(LPCTSTR)str
BSTR variable
str = "Juegos Olímpicos de Beijing 2008"; p>
BSTR bstrValue = :: SysAllocString(L"Programador");
char * buf = _com_util::ConvertBSTRToString(bstrValue);
SysFreeString(bstrValue); /p>
AfxMessageBox(buf);
eliminar(buf);
variable CComBSTR
CComBSTR bstrVar("prueba"); >
char *buf = _com_util ::ConvertBSTRToString(bstrVar.m_str);
AfxMessageBox(buf
eliminar
_bstr_t); variable
_b
El tipo str_t es un paquete de BSTR. Debido a que el operador = ha sido sobrecargado, es fácil de usar
_bstr_t bstrVar("test"); ; /// No modifique el contenido en buf
AfxMessageBox(buf);
Método general (para tipos de datos no COM)
Utilice sprintf para completar la conversión
p>char buffer[200]
char c = '1'
int i = 35; > largo j = 1000;
float f = 1.7320534f;
sprintf( búfer, "%c",c
sprintf( búfer, "); %d",i);
sprintf( búfer, "%d",j);
sprintf( búfer, "%f",f);
2. Conversión de cadenas Para otros tipos de datos
strcpy(temp,"123"
Entero corto (int)
i = atoi(temp)
Entero largo (largo)
l = atol(temp
Coma flotante (doble)
d = atof); (temp);
variable CString
nombre CString = temp
variable BSTR
BSTR bstrValue = ::SysAllocString(L" Programmer") ;
...///Completar el uso de bstrValue
SysFreeString(bstrValue);
variable CComBSTR
Variable de tipo CComBSTR Se puede asignar directamente
CComBSTR bstrVar1("test"
CComBSTR bstrVar2(temp
_bstr_t variable
_bstr_t bstrVar1("test");
_bstr_t bstrVar2(temp
3. tipos de datos a CString
Utilice la función miembro Formato de CString para convertir, por ejemplo:
Entero (int)
str.Format("%d" ,i);
Número de coma flotante (flotante)
str.Format("%f",i
Puntero de cadena (char *) y otros tipos de datos ya admitidos por el constructor CString Se pueden asignar directamente
str =
nombre de usuario;
Para los tipos de datos que el formato no admite, primero puede convertir a char * mediante el método mencionado anteriormente para convertir otros tipos de datos a char * y luego asignar el valor a la variable CString.
4. BSTR, _bstr_t y CComBSTR
CComBSTR es la encapsulación de BSTR de ATL, _bstr_t es la encapsulación de BSTR de C++, BSTR es un puntero de 32 bits, pero no apunta directamente a un zona de amortiguamiento de cadena.
Convierta char * a BSTR de esta manera:
BSTR b=_com_util::ConvertStringToBSTR("data");/// Debe agregar comutil.h y comsupp.lib antes use
SysFreeString(bstrValue);
De lo contrario, puede usar
char *p=_com_util::ConvertBSTRToString(b); eliminar p ;
Para más detalles, consulte las instrucciones específicas en los párrafos 1 y 2.
CComBSTR y _bstr_t han sobrecargado una gran cantidad de operadores y pueden realizar directamente operaciones como =,!=,==, etc., por lo que son muy convenientes de usar.
Especialmente _bstr_t, se recomienda que todos lo utilicen.
5. VARIANT, _variant_t y COleVariant
Para conocer la estructura de VARIANT, consulte la definición de la estructura tagVARIANT en el archivo de encabezado VC98\Include\OAIDL.H.
Para la asignación de variables VARIANT: primero asigne un valor al miembro vt, especifique el tipo de datos y luego asigne un valor a las variables del mismo tipo de datos en la estructura de unión, por ejemplo:
VARIANT va;
int a=2001;
va.vt=VT_I4;///Especificar datos enteros
va.lVal =a; ///Assignment
Para las VARIANT que no se asignan inmediatamente, es mejor usar Void VariantInit(VARIANTARG FAR* pvarg); La esencia es configurar vt en VT_EMPTY. la tabla enumera la correspondencia entre vt y los datos de uso común:
Byte bVal; // VT_UI1
Short iVal;
long lVal; / VT_I4
float fltVal ; // VT_R4
doble dblVal
VARIANT_BOOL; p> SCODE scode; // VT_ERROR.
CY cyVal; // VT_CY
fecha VT_BSTR.
DECIMAL FAR* pdecVal // VT_BYREF|VT_DECIMAL
IUnknown FAR* punkVal; // VT_UNKNOWN
IDispatch FAR* pdispVal.
SAFEARRAY FAR* parray; // VT_ARRAY|*.
Byte FAR* pbVal; // VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2.
long FAR* plVal; // VT_BYREF|VT_I4.
float FAR* pfltVal; // VT_BYREF|VT_R4. pdblVal; // VT_BYREF|VT_R8.
VARIANT_BOOL FAR* pboolVal; // VT_BYREF|VT_ERROR
> CY FAR* pcyVal; // VT_BYREF|
VT_CY.
FECHA FAR* pdate; // VT_BYREF|VT_DATE.
BSTR FAR* pbstrVal; // VT_BYREF|VT_BSTR
IUnknown FAR*. ppunkVal; // VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; // VT_ARRAY|*. p>
VARIANT FAR* pvarVal; // VT_BYREF|VT_VARIANT.
void FAR* byref; // Genérico ByRef. >
uiVal corto sin signo; // VT_UI2.
ulVal largo sin signo; // VT_UI4 int Val; uintVal; // VT_UINT.char FAR * pcVal; // VT_BYREF|VT_I1
unsigned short FAR * puiVal; unsigned long FAR * pulVal; // VT_BYREF|VT_UI4.
int FAR * pintVal; // VT_BYREF|VT_UINT. /p>
_variant_t es una clase contenedora de VARIANT. Su asignación puede utilizar conversión de tipo forzada y su constructor manejará automáticamente estos tipos de datos.
Debe agregar #include
cuando lo use. Por ejemplo:
long l=222; > ing i= 100;
_variant_t lVal(l);
lVal = (long)i
El uso de COleVariant es básicamente el mismo. de _variant_t, consulte el siguiente ejemplo:
COleVariant v3 = "String", v4 = (long)1999
CString str =(BSTR)v3.pbstrVal
long i = v4.lVal;
6. Algunos otros tipos de datos COM
Obtener CLSID basado en ProgID
HRESULT CLSIDFromProgID(LPCOLESTR lpszProgID ,LPCLSID pclsid);
CLSID clsid
CLSIDFromProgID( L"MAPI.Folder",&clsid
Obtener ProgID basado en CLSID
WINOLEAPI ProgIDFromCLSID( REFCLSID clsid, LPOLESTR * llppszProgID);
Por ejemplo, hemos definido CLSID_IApplication, el siguiente código obtiene ProgID
LPOLESTR pProgID = 0
;ProgIDFromCLSID( CLSID_IApplication,&pProgID);
...///Puedes usar pProgID
CoTaskMemFree(pProgID);//No olvides liberar
7. ANSI y Unicode
Unicode se denomina cadena de caracteres ancha y todas las cadenas Unicode utilizadas en COM son cadenas Unicode.
Convertir ANSI a Unicode
(1) Implementado a través de la macro L, por ejemplo: CLSIDFromProgID( L"MAPI.Folder",&clsid); 2) La conversión se logra mediante la función MultiByteToWideChar, por ejemplo:
char *szProgID = "MAPI.Folder"
WCHAR szWideProgID[128]; CLSID clsid ;
long lLen = MultiByteToWideChar(CP_ACP,0,szProgID,strlen(szProgID),szWideProgID,sizeof(szWideProgID));
szWideProgID[lLen] = '\0'
(3) Implementado a través de la macro A2W, por ejemplo:
USES_CONVERSION
CLSIDFromProgID( A2W(szProgID),&clsid; p> Convertir Unicode a ANSI
(1) Utilice WideCharToMultiByte, por ejemplo:
// Supongamos que ya existe una cadena Unicode wszSomeString...
char szANSIString [ MAX_PATH];
WideCharToMultiByte ( CP_ACP, WC_COMPOSITECHECK, wszSomeString, -1, szANSIString, sizeof(szANSIString), NULL, NULL
(2) Utilice la macro W2A para implementar, por ejemplo:
USES_CONVERSION;
pTemp=W2A(wszSomeString);
8. Otros
Al procesar mensajes, a menudo es necesario descomponer datos de 32 bits (DWORD), como WPARAM o LPARAM, en dos datos de 16 bits (WORD), por ejemplo:
LPARAM lParam
WORD loValue =; LOWORD(lParam);// /Obtiene los 16 bits inferiores
WORD hiValue = HIWORD(lParam); ///Obtiene los 16 bits superiores
Para datos de 16 bits (WORD) ), podemos usar el mismo método para descomponerlo en dos datos de 8 bits alto y bajo (BYTE), por ejemplo:
WORD wValue
BYTE loValue = LOBYTE(wValue; ); ///Toma los 8 bits bajos
BYTE hiValue = HIBYTE(wValue); ///Toma los 8 bits altos
Dos datos de 16 bits (WORD) sintetizados en Datos de 32 bits (DWORD, LRESULT, LPARAM o WPARAM)
LONG MAKELONG( WORD wLow, WORD wHigh
WPARAM MAKEWPARAM( WORD wBajo, WORD wHigh
LPARAM MAKELPARAM( WORD wBajo, WORD wHigh );
LRESULT MAKELRESULT( WORD wLow, WORD wHigh );
Dos datos de 8 bits (BYTE) se combinan en datos de 16 bits (WORD)
WORD MAKEWORD( BYTE bLow, BYTE bHigh )
Obtiene el valor de color del tipo COLORREF de los tres colores R(rojo), G(verde), B(azul)
COLORREF RGB( BYTE porRojo, BYTE porVerde; , BYTE byBlue );
Por ejemplo, COLORREF bkcolor = RGB(0x22,0x98,0x34
Obtiene tres valores de color RGB del valor de color del tipo COLORREF
BYTE Red = GetRValue(bkcolor); ///Obtener el color rojo
BYTE Green = GetGValue(bkcolor); ///Obtener el color verde
BYTE Blue = GetBValue(bkcolor); ///Obtener el color azul
Notas
Si necesita utilizar funciones como ConvertBSTRToString, debe agregar el archivo de encabezado comutil.h y agregue comsupp.lib a la configuración o agregue directamente el comentario #pragma (lib, "comsupp.lib")
Además, Tuan IDC tiene muchas compras de grupos de productos en línea, que son económicas y tienen buena reputación.