La diferencia entre lpctstr y cstring

l = atol(temp);

Coma flotante (doble)

d = atof( temp);

4. Convierta otros tipos de datos a CString

Utilice la función miembro Formato de CString para convertir, por ejemplo:

Entero (int)

str.Format("%d",i);

Flotante (flotante)

str.Format("%f",i);

Datos tipos como punteros de cadena (char *) que han sido admitidos por el constructor CString se pueden asignar directamente

str = nombre de usuario;

5.

CComBSTR y _bstr_t son encapsulaciones de BSTR, que es un puntero de 32 bits a una cadena.

Char * se puede convertir a BSTR de esta manera: BSTR b=_com_util::ConvertStringToBSTR("data"); //Debes agregar el archivo de encabezado comutil.h antes de usarlo

Por el contrario, puede utilizar char *p=_com_util::ConvertBSTRToString(b);

6. VARIANT, _variant_t y COleVariant

Para conocer la estructura de VARIANT, consulte la estructura en el archivo de encabezado VC98\Include\OAIDL.H Definición de tagVARIANT.

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; //Asignación

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 correspondencia entre vt y los datos de uso común:

unsigned char bVal;

short iVal;

long VT_I4

float fltVal; VT_BOOL

código SCODE

CY VT_CY

; p>

FECHA fecha; VT_DATE

BSTR bstrVal; VT_BSTR

IUnknown FAR* VT_UNKNOWN

IDispatch FAR* pdispVal

SAFEARRAY FAR* parray; VT_ARRAY|*

unsigned char FAR* pbVal; VT_BYREF|VT_UI1

short FAR* piVal; FAR* plVal; VT_BYREF|VT_I4

float FAR* pfltVal; VT_BYREF|VT_R4

doble FAR* pdblVal; |VT_BOOL

SCODE FAR* pscode; VT_BYREF|VT_ERROR

CY FAR* pcyVal; VT_BYREF|VT_CY

FECHA FAR* pdate; >

BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR

IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN

IDispatch FAR* FAR* ppdispVal;

SAFEARRAY FAR* FAR* pparray; VT_ARRAY| *

VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT

void FAR* byref; la clase de encapsulación de VARIANT y su asignación pueden utilizar conversión de tipo forzada, su constructor maneja automáticamente estos tipos de datos.

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;

long i = v4.lVal;

7. Otros

Al procesar 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 hiValue = HIWORD(lParam); //Toma los 16 bits superiores

Para datos de 16 bits (WORD) podemos usar el mismo método para descomponerlos en dos datos de 8 bits (BYTE), alto y bajo, por ejemplo:

WORD wValue;

BYTE loValue = LOBYTE(wValue); //Obtener los 8 bits inferiores

BYTE hiValue = HIBYTE(wValue); //Obtener los 8 bits superiores

Cómo asignar un Variable de tipo CString a una variable de tipo char*

1. Función GetBuffer:

Utilice la función CString::GetBuffer.

char *p;

CString str="hola"

p=str.GetBuffer(str.GetLength()); p>str.ReleaseBuffer();

Al convertir CString a char *

CString str("aaaaaaa");

strcpy(str.GetBuffer( 10 ), "aa");

str.ReleaseBuffer();

Cuando necesitamos una matriz de caracteres, llamamos a GetBuffer(int n), donde n es la matriz de caracteres que necesitamos. Asegúrese de llamar a ReleaseBuffer() inmediatamente después de su uso;

Otro punto muy importante es que cuando se pueda usar const char *, no use char *

2, memcpy: <. /p>

CString mCS=_T("cxl");

char mch[20]

memcpy(mch,mCS,20);

3. Utilice LPCTSTR para forzar la conversión: intente no utilizar

char *ch

CString str

ch=(LPSTR)( LPCTSTR) str;

CString str = "bueno";

char *tmp;

sprintf(tmp,"%s",(LPTSTR)(LPCTSTR )str );

4.

CString Msg

Msg=Msg+"abc"

LPTSTR lpsz; p>lpsz = nuevo TCHAR[Msg.GetLength()+1];

_tcscpy(lpsz, Msg);

char * psz; psz,lpsz);

Clase CString para const char * conversión

char a[100];

CString str("aaaaaa");

strncpy(a,(LPCTSTR)str,sizeof(a));

O de la siguiente manera:

strncpy(a,str,sizeof(a)); /p>

Ambos usos anteriores son correctos debido a que el segundo tipo de parámetro de strncpy es const char *, el compilador convertirá automáticamente la clase CString en const char *.

CString a LPCTSTR (. const char *)

CString cStr;

const char *lpctStr=(LPCTSTR)cStr;

LPCTSTR a CString

LPCTSTR lpctStr ;

CString cStr=lpctStr;

Asignar una variable de tipo char* a una variable de tipo CString

Puedes asignar un valor directamente, como por ejemplo: < / p>

CString myString = "Esto es una prueba";

También puedes usar el constructor, como por ejemplo:

CString s1("Tom");

Asignar variables de tipo CString a variables de tipo char [] (cadena)

1. función sprintf()

CString str = "good";

char tmp[200] ;

s

printf(tmp, "%s",(LPCSTR)str);

La conversión forzada de (LPCSTR)str es equivalente a (LPTSTR)(LPCTSTR)str

Variables del Clase CString Cuando necesite convertir a (char*), use (LPTSTR)(LPCTSTR)str

Sin embargo, LPCTSTR es constante char *, lo que significa que no se puede escribir en la cadena resultante. ¡Forzarlo a LPTSTR y eliminar la constante es extremadamente peligroso!

¡Si no tienes cuidado, estarás condenado! Para obtener char *, debe usar GetBuffer() o GetBufferSetLength() y luego llamar a ReleaseBuffer() después de su uso.

2. función strcpy()

CString str;

char c[256];

strcpy(c, str);

char mychar[1024];

CString source="Hola";

strcpy((char*)&mychar,(LPCTSTR)source); p>

Acerca del uso de CString

1. Especificar parámetros formales de CString

Para la mayoría de las funciones que requieren parámetros de cadena, es mejor especificar los parámetros formales en el archivo. prototipo de función como un puntero constante a un carácter (LPCTSTR) en lugar de un CString.

Cuando especifica un parámetro como un puntero constante a un carácter, puede pasar el puntero a una matriz TCHAR (como una cadena ["hola"]) o a un objeto CString.

Los objetos CString se convierten automáticamente a LPCTSTR. En cualquier lugar donde pueda usar un LPCTSTR, también puede usar un objeto CString.

2. Si no se va a modificar un parámetro formal, especifique también el parámetro como una referencia de cadena constante (es decir, const CString&). Si la función modifica la cadena,

elimine el modificador constante. Si necesita establecer un valor nulo de forma predeterminada, inicialícelo en una cadena vacía [""] de la siguiente manera:

void AddCustomer( const CString& nombre, const CString& dirección, const CString& comentario = "" ); /p>

3. Para la mayoría de los resultados de las funciones, simplemente devuelva un objeto CString por valor.

Operaciones básicas en cadenas

Para operaciones básicas en cadenas, muchos lenguajes de alto nivel proporcionan los operadores correspondientes o funciones de biblioteca estándar para implementarlas.

Para facilitar la descripción, primero se definen varias variables relacionadas:

char s1[20]="dir/bin/appl",s2[20]="file.asm " ,s3[30],*p;

int result;

A continuación se utilizan operaciones de cadenas en lenguaje C para presentar las operaciones básicas de cadenas

1 Encuentra la longitud de la cadena

int strlen(char *s); // Encuentra la longitud de la cadena s

Ejemplo printf("%d",strlen(s1)) ; // Muestra la longitud de la cadena de s1 12

2. Copia de cadena

char *strcpy(char *to,*from); y devuelve el puntero al principio de to

Ejemplo strcpy(s3,s1); //s3="dir/bin/appl", la cadena s1 permanece sin cambios

3. Conexión

char *strcat( char *to,char *from);// Copia la cadena from al final de la cadena to,

//Y devuelve el puntero al principio de la cadena

Ejemplo strcat(s3, "/"); //s3="dir/bin/appl/"

strcat(s3,s2); //s3="dir/bin/appl/file.asm"

4. Comparación de cadenas

int strcmp(char *s1,char *s2);//Compara los tamaños de s1 y s2,

//Cuando s1Cuando s2 y s1=s2, devuelven valores menores que 0, mayores que 0 e iguales a 0 respectivamente

Ejemplo resultado=strcmp("panadero","Panadero"); //resultado>0

resultado=strcmp("12","12"); //resultado=0

resultado=strcmp("Joe","joseph") //resultado<0

5. Posicionamiento de caracteres

char *strchr(char *s,char c);/ /Encuentra la posición donde c aparece por primera vez en la cadena s,

// Si la encuentra, devuelve la posición; de lo contrario, devuelve NULL

Ejemplo p=strchr(s2,'.'); //p apunta a la posición después de "archivo"

if(p ) strcpy(p,".cpp"); //s2="file.cpp"

Nota:

①Las operaciones anteriores son las más básicas y las últimas cuatro operaciones también. Hay variantes: strncpy, strncath y strnchr.

②Para otras operaciones con cadenas, consulte de C.

En diferentes lenguajes de alto nivel, los tipos y símbolos de las operaciones de cadena son diferentes

③El resto de las operaciones de cadena generalmente se pueden combinar a partir de estas operaciones básicas

Ejemplo de búsqueda de una subcadena La operación se puede implementar de la siguiente manera:

void substr(char *sub,char *s,int pos,int len){

//s y sub son matrices de caracteres, use sub para devolver una cadena Una subcadena de longitud len comenzando desde el carácter pos-ésimo de s

//Donde 0<=pos<=strlen(s)-1, y la matriz sub puede contener al menos len +1 caracteres.

if (pos<0||pos>strlen(s)-1||len<0)

Error("¡error de parámetro!");

strncpy(sub,&s[pos],len); //Copia hasta len caracteres de s[pos] a sub