¿Cómo convertir caracteres hexadecimales en vc?
Categoría: Computadora/Red gt; Hardware
Descripción del problema:
Cuando des está cifrado y descifrado, el texto cifrado es una cadena de caracteres confusos. . String, conviértalo a hexadecimal para una mejor visualización. Entonces, al descifrarlo, ¿cómo convertirlo a la cadena anterior?
Análisis:
Los amigos que son nuevos en la programación de VC a menudo se sienten confundidos acerca de la conversión de muchos tipos de datos. 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;
double d=12345.119;
char nombre de usuario[]="Cheng Peijun"
char temp[200]; p> char *buf;
CString str;
_variant_t v1;
_bstr_t v2
1. Convertir otros tipos de datos a strings
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); p> Número de coma flotante (flotante, doble)
La conversión se puede completar usando fcvt, este es un ejemplo de MSDN:
int decimal, sign
char *buffer;
doble fuente = 3.************;
buffer = _fcvt( fuente, 7, amp; decimal, amp; signo) ;
Resultados de ejecución: fuente: 3.****************** búfer: '*************** **' 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
Variable CString
str = "Juegos Olímpicos de Beijing 2008";
buf = (LPSTR)(LPCTSTR)str
variable BSTR
BSTR bstrValue; = ::SysAllocString(L"Programador");
char *buf = __util::ConvertBSTRToString(bstrValue);
SysFreeString(bstrValue); (buf
eliminar(buf);
p>
variable CComBSTR
CComBSTR bstrVar("prueba"); p> char *buf = __util::ConvertBSTRToString(bstrVar.m_str);
AfxMessageBox(buf);
eliminar
_bstr_t variable<; /p>
El tipo _bstr_t es una encapsulación de BSTR porque el operador = ha sido sobrecargado, por lo que es fácil de usar
_bstr_t bstrVar("test"); const char *buf = bstrVar;/No modificar el contenido en buf
AfxMessageBox(buf);
Método general (para tipos de datos no COM)
Utilice sprintf para completar la conversión
char buffer[200]
p>
char c = '1';
int i = 35
largo j = 1000; > float f = 1.7320534f;
sprintf( búfer, "c", c
sprintf( búfer, "d", i
); sprintf( buffer, "d", j);
sprintf( buffer, "f", f
2. Convertir cadenas a otros tipos de datos
Tipo entero corto (int)
i = atoi(temp
Tipo entero largo (long)
l = atol(temp);
Punto flotante (doble)
d = atof(temp);
CString variable<; /p>
CString nombre = temp;
variable BSTR
BSTR bstrValue = ::SysAllocString(L"Programador"
... /Completar el uso de bstrValue
SysFreeString(bstrValue);
variable CComBSTR
A las variables de tipo CComBSTR se les pueden asignar valores directamente
CComBSTR bstrVar1("test");
CComBSTR bstrVar2(temp);
_bstr_t variable
A las variables de tipo _bstr_t se les pueden asignar valores directamente
_bstr_t bstrVar1("test");
_bstr_t bstrVar2(temp);
3. Convierta otros tipos de datos a CString
la función miembro Formato de CString a convertir, por ejemplo:
Entero (int)
str.Format("d", i
Punto flotante); número (flotante)
str.Format("f ", i);
Los punteros 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 no son compatibles con el formato, 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.
La conversión de char * a BSTR se puede hacer así:
BSTR b=__util::ConvertStringToBSTR("data");/Necesita agregar util.h y supp.lib antes de usar
p>
SysFreeString(bstrValue);
Por el contrario, puedes usar
char *p=__util::ConvertBSTRToString(b). );
eliminar p;
Para obtener más información, 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; ; /Asignar valor
Para las VARIANT que no se asignan inmediatamente, es mejor usar Void VariantInit(VARIANTARG FAR* pvarg); La esencia es establecer vt en VT_EMPTY. correspondencia entre vt y datos de uso común:
Byte bVal;
iVal corto;
lVal largo; > flotante fltVal;
doble VT_R8
VARIANT_BOOL VT_BOOL
código VT_ERROR. cyVal; VT_CY.
FECHA VT_DATE
BSTR bstrVal
DECIMAL FAR* pdecVal VT_BYREF|VT_DECIMAL. IUnknown FAR* punkVal;
IDispatch FAR* pdispVal;
SAFEARRAY FAR* VT_ARRAY|*
Byte FAR* pbVal; |VT_UI1.
corto FAR* piVal; VT_BYREF|VT_I2.
largo FAR* plVal;
flotante FAR* pfltVal;
doble FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_ERROR. /p>
CY FAR* pcyVal; VT_BYREF| VT_CY
FECHA FAR* pdate; VT_DATE
BSTR FAR* pbstrVal. >
IDesconocido FAR* FAR* ppunkVal; VT_BYREF| VT_UNKNOWN.
IDispatch FAR* FAR* ppdispVal;
VA
RIANT FAR* pvarVal; VT_BYREF|VT_VARIANT.
void FAR* byref; /p>
ulVal largo sin firmar
int VT_INT.
int VT_UINT sin signo
char FAR * VT_BYREF. |VT_I1.
LEJOS cortos sin firmar * puiVal; VT_BYREF|VT_UI2.
LEJOS largos sin firmar * VT_BYREF|VT_UI4. |VT_INT.
unsigned int FAR * puintVal; VT_BYREF|VT_UINT.
_variant_t es una clase contenedora de VARIANT. Su asignación puede utilizar conversión de tipo forzada y su constructor los manejará automáticamente. tipo de datos.
Necesitas agregar #include lt; def.hgt;
Por ejemplo:
long l=222
ing i; =100;
_variant_t lVal(l);
lVal = (long)i
El uso de COleVariant es básicamente el mismo que el de _variant_t, consulte el siguiente ejemplo:
COleVariant v3 = "String", v4 = (long)1999
CString str = (BSTR)v3.pbstrVal
<; p> long i = v4.lVal;6. Algunos otros tipos de datos COM
Obtenga CLSID basado en ProgID
HRESULT CLSIDFromProgID(LPCOLESTR lpszProgID, LPCLSID pclsid );
p>
CLSID clsid;
CLSIDFromProgID( L"MAPI.Folder", amp; clsid
Obtener ProgID basado en CLSID);
WINOLEAPI ProgIDFromCLSID( REFCLSID clsid, LPOLESTR * llpszProgID);
Por ejemplo, hemos definido CLSID_IApplication, el siguiente código obtiene ProgID
LPOLESTR pProgID = 0;
ProgIDFromCLSID( CLSID_IApplication, amp; pProgID);
.../Puedes usar pProgID
CoTaskMemFree(pProgID); /p>
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", amp; clsid
< p); > (2) La conversión se logra mediante la función MultiByteToWideChar, por ejemplo:char *szProgID = "MAPI.Folder"
WCHAR szWideProgID[128]; p> 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), amp; clsid); /p >
Convertir Unicode a ANSI
(1) Utilice WideCharToMultiByte, por ejemplo:
Suponga 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 W2A); macro para implementar, por ejemplo:
USES_CONVERSION;
pTemp=W2A(wszSomeString);
8. Otros
Usamos 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); /Obtener los 16 bits inferiores
WORD hiValue = HIWORD(lParam);/Obtener los 16 bits superiores
Para datos de 16 bits (WORD), podemos use el mismo método para descomponerlo en datos de 8 bits altos y bajos (BYTE), por ejemplo:
WORD wValue
BYTE loValue = LOBYTE(wValue);/Tome el 8 bits inferiores
BYTE hiValue = HIBYTE(wValue);/Tome los 8 bits superiores
Dos datos de 16 bits (WORD) sintetizan datos de 32 bits (DWORD, LRESULT, LPARAM , o WPARAM)
LONG MAKELONG( WORD wBajo, WORD wAlto);
WPARAM MAKEWPARAM( WORD wBajo, WORD wAlto);
LPARAM MAKELP;
ARAM(WORD wLow, WORD wHigh);
LRESULT MAKELRESULT(WORD wLow, WORD wHigh);
Dos datos de 8 bits (BYTE) se sintetizan 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 porAzul
Por ejemplo, COLORREF bkcolor = RGB(0x22, 0x98, 0x34); del tipo COLORREF a RGB tres valores de color
BYTE Red = GetRValue(bkcolor /Obtener el color rojo
BYTE Green = GetGValue(bkcolor); p>
BYTE Blue = GetBValue(bkcolor); /Obtener el color azul
9. Notas
Si necesita utilizar funciones como ConvertBSTRToString, debe agregar el archivo de encabezado util.h y agréguelo en Agregar supp.lib a la configuración o agregue directamente #pragma ment( lib, "supp.lib")