¿Cómo convertir 16 en caracteres en vc?
Descripción del problema:
Cuando se utiliza descifrado y descifrado, el texto cifrado es una cadena de caracteres confusos. Para facilitar la visualización, es. convertido en un sistema de 16 hexágonos. Entonces, ¿cómo convertirlo a la cadena anterior al descifrarlo?
Análisis:
Los amigos que son nuevos en la programación de VC a menudo se sienten confundidos por la conversión de muchos tipos de datos. Este artículo presentará el uso de algunos tipos de datos comunes.
Primero definamos algunos tipos de variables comunes para ilustrar.
int I = 100;
long l = 2001;
coma flotante f = 300,2
doble d = 12345,119;
p>p>
Char nombre de usuario[]= "Cheng Peijun";
Temperatura de carbonización[200];
char * buf
CString string ;
_ var _ t v 1;
_ bstr _ t v2
Primero, otros tipos de datos se convierten en cadenas
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
long(long)
ltoa(l,temp,10);
ltoa(l,temp,10);
p>
Números de punto flotante (punto flotante, doble precisión)
La conversión se puede realizar con fcvt , aquí hay un ejemplo de MSDN:
int decimal, sign;
char *buffer;
dual source = 3. ***********;
buffer = _fcvt(fuente, 7 & decimal. firmado);
Resultado de la ejecución: fuente: 3. * * * * * * * * Búfer: "* * * * * * * * *" Número 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;
bstr bstr value =::sysallocstring(l"programador");
char * buf = _ _ util::ConvertBSTRToString(bstrValue);
SysFreeString (bstrValue);
AfxMessageBox(buf);
Eliminar(buf);
Variable CComBSTR
CComBSTR bstr var(" prueba ");
char * buf = _ _ util::ConvertBSTRToString(bstr var . m _ str);
AfxMessageBox(buf);
Eliminar ( buf);
Variable _bstr_t
El tipo _BSTR_t es un contenedor de BSTR Debido a que el operador = ha sido sobrecargado, es fácil de usar.
_ bstr _ t bstr var(" 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];
char c = ' 1 ';
int i = 35
Longitud j = 1000;
flotante f = 1.7320534 f;
sprintf(búfer, "%c", c
sprintf(búfer, "%d", I
); sprintf(buffer, "%d", j);
sprintf(buffer, "%f", f);
En segundo lugar, la cadena se convierte a otro tipo de datos
strcpy(temp, " 123 ");
Entero corto (int)
I = atoi(temp);
largo (largo )
l = atol(temperatura);
Punto flotante (doble)
d = atof(temperatura);
CString variable
CString nombre = temp
Variable BSTR
bstr valor bstr =::sysallocstring(l"programador");
.. ./Termina con bstrValue.
SysFreeString(bstrValue);
Variable CComBSTR
A las variables de tipo CComBSTR se les pueden asignar valores directamente.
CComBSTR bstr var 1(" prueba ");
CComBSTR bstr VR 2(temp
_bstr_t variable
tipo _bstr_t); A las variables se les pueden asignar valores directamente.
_ bstr _ t bstr var 1(" test ");
_ bstr _ t bstr var 2(temp);
Tercero, otros datos El el tipo se convierte a CString
Utilice el formato de función miembro de CString para la conversión, por ejemplo:
Entero
Str. format(" %d ",i);
Número de punto flotante
str. Formato (" %f ", I);
Los tipos de datos que ya admite el constructor CString, como los punteros de cadena (char *), se pueden asignar directamente.
str = nombre de usuario;
Para los tipos de datos que el formato no admite, primero puede recurrir a char * y luego convertir otros tipos de datos a char * mediante el método asignado anteriormente. a la variable CString.
Cuatro. BSTR _ bstr _ t y CComBSTR
CCombstr es la encapsulación de BSTR de ATL, _bstr_t es la encapsulación de BSTR de C++ y BSTR es un puntero de 32 bits, pero no apunta directamente al búfer de una cadena.
Char * se puede convertir a BSTR de esta manera:
BSTR b = _ _ util::convertstringtobstr(" data ");/Necesitas agregar util.h y supp antes uso.
SysFreeString(bstrValue);
En su lugar, puedes usar
char * p = _ _ util::ConvertBSTRToString(b);
Eliminar p;
Consulte el primer y segundo párrafo para obtener más detalles.
CComBSTR y _bstr_t sobrecargan una gran cantidad de operadores, puedes directamente =,! =, = =, etc., por lo que es muy conveniente de usar.
Especialmente _bstr_t, se recomienda que todos lo utilicen.
v variante, _variant_t y COleVariant
La estructura de VARIANT puede hacer referencia a la definición de la estructura tagVARIANT en el archivo de encabezado vc98\include\oaidl.h.
Asignación de variables: Primero asigne un valor al miembro vt para indicar 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:
Variación va;
int a = 2001;
va.vt = VT _ I4/ representa datos enteros.
va .lval = a;/assignment
Para las variantes que no se asignan inmediatamente, es mejor usar Void Variant init (Variant arg far * pvarg); es cambiar vt Establecer en VT_EMPTY. En la siguiente tabla enumeramos la correspondencia entre vt y los datos públicos:
Byte bValVT_UI1.
Corto iValVT_I2.
lValVT_I4 larga.
Válvula Flotador Flotador;
doble dblValVermontR8.
VARIANT_BOOL boolValVT_BOOL.
Scott Scord; VT_Error.
CY cyValVT_CY.
Fecha fecha; VT_DATE.
BSTR·bstr val;
DECIMAL FAR * PDE cval VT_BYREF |
IUnknown FAR*punkValVT _Unknown.
IDispatch FAR * pdispVal despacho.
SAFEARRAY LEJOS * parrayVT_ARRAY|*.
Byte FAR * pbValVT_BYREF|VT_UI1.
Eje distal corto; VT_BYREF|VT_I2.
largo FAR * plValVT_BYREF|VT_I4.
flotar LEJOS * pfltValR4.
doble FAR* pdblValR8.
VARIANT_BOOL FAR*pboolValVT_BYREF|VT_BOOL.
SCODE FAR * pscodeVT_BYREF|VT_ERROR
CY FAR * pcyValVT_BYREF.
FECHA LEJOS *pdateVT_BYREF.
BSTR LEJOS * pbstrVal;BSTR.
IUnknown FAR * FAR * ppunkVal desconocido.
IDispatch FAR * FAR * ppdispValBYREF |
SAFEARRAY FAR*FAR* pparrayVT_ARRAY|*.
VARIANTE FAR * pvarValVT_BYREF|VT_VARIANT.
void FAR * byref universal ByRef.
char cValVT_I1.
UiValVT_UI2 corto sin firmar.
Tipo de entero largo sin signo ulValVT_UI4.
int intValVT_INT.
Int sin firmar uintValVT_UINT.
char FAR * pcValVT_BYREF|VT_I1.
FAR corto sin firmar * puiValVT_BYREF|VT_UI2.
FAR largo sin firmar * pulValVT_BYREF|VT_UI4.
int FAR * pintValVT_BYREF.
Unsigned int FAR * puintValVT_BYREF|VT_UINT
_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.
Agregar # incluir
Por ejemplo:
Long l = 222
ing I = 100;
_ variante _ t lVal(l);
lVal =(long)I;
El uso de COleVariant es básicamente el mismo que _variant_t, consulte el siguiente ejemplo:
COleVariant v3 = "cadena", v4 = (long)1999;
CString str = (BSTR)v3
long i = v4.lVal<. /p>
6. Algunos otros tipos de datos COM
Obtener CLSID basado en ProgID
HRESULT CLSIDFromProgID(LPCOLESTR lpszProgID, LPCLSID PCL sid);
CLSID clsid
CLSIDFromProgID(L"MAPI.Folder", & ampclsid);
Obtener ProgID basado en CLSID
WINOLEAPI ProgIDFromCLSID(ref clsid clsid, LPO lestr * llpszProgID);
Por ejemplo, si definimos CLSID_IApplication, el siguiente código obtendrá ProgID.
LPOLESTR ppro GID = 0;
CLSID(CLSID _ I aplicación & pProgID
.../ pProgID se puede utilizar.
CoTaskMemFree(pProgID); no olvides liberar
Siete. ANSI y Unicode
Unicode se denomina cadena ancha y todas las cadenas Unicode se utilizan en COM.
La conversión de ANSI a Unicode
(1) se implementa mediante la macro l, como clsidfromprogid(l "mapi. carpeta", & clsid);
( 2) La conversión se logra mediante la función MultiByteToWideChar, por ejemplo:
char *szProgID = "MAPI.
carpeta";
WCHAR szWideProgID[128];
CLSID clsid
long lLen = MultiByteToWideChar(CP_ACP, 0, szProgID, strlen(szProgID) , szWideProgID, sizeof(szWideProgID));
szWideProgID[lLen]= '\0';
(3) Tome la macro A2W como ejemplo:
USES _ CONVERSION
CLSIDFromProgID(A2W)clsid);
Convertir Unicode a ANSI
(1) Utilice WideCharToMultiByte, por ejemplo:
Supongamos que ya tiene una cadena Unicode wszSomeString. NULL, NULL);
(2) Tome la macro W2A como ejemplo:
USES _ CONVERSION
pTemp = W2A(wszSomeString);
8. Otros
Durante el procesamiento de mensajes, a menudo necesitamos 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);/Toma los 16 bits inferiores
WORD hi value = hi WORD(lParam);/Toma los 16 bits; alto
Para datos de 16 bits (palabra), podemos usar el mismo método para descomponerlos en dos datos de 8 bits (bytes), por ejemplo:
WORD wValue
BYTE loValue = LOBYTE(wValue);/8 bits inferiores
BYTE hi value = hola BYTE(wValue);/tome los 8 bits altos
Dos. Los datos de 16 bits (palabras) se combinan en datos de 32 bits (DWORD, LRESULT, LPARAM o WPARAM).
LONG MAKELONG (palabra wBajo, palabra wAlto);
WPARAM MAKEWPARAM (palabra wBajo, palabra wAlto);
LPARAM MAKELPARAM (palabra wBajo, palabra wAlto); ;
LRESULT MAKELRESULT(WORD wLow, WORD wHigh);
Dos datos de 8 bits (bytes) se combinan en datos de 16 bits (palabra).
WORD MAKEWORD(BYTE bLow, BYTE b high);
Los valores de color de tipo COLORREF se obtienen de R (rojo), G (verde) y B (azul).
COLORREF RGB (byte rojo, byte verde, byte azul);
Por ejemplo, colorref bkcolor = RGB (0x22, 0x98, 0x 34); Obtenga tres valores de color RGB a partir de un valor de color de tipo COLORREF.
BYTE Rojo = getr valor(color negro);/Obtener rojo
BYTE Verde = GetGValue(color negro);/Obtener verde
BYTE Azul = getb value(bk color);/Get blue
9. Notas
Si necesita usar una función como ConvertBSTRToString, debe agregar el archivo de encabezado util.h y agregar supp. la configuración. lib o agregue #pragmation (lib, "supp.lib") directamente.