Los cuatro tipos de conversiones en C ++ son: const_cast, static_cast, dynamic_cast, reinterpret_cast; este es un tema muy común en C ++, especialmente para los recién llegados. Entonces ...
En términos generales, se producirán las siguientes situaciones en la conversión de tipos:
-int conversion float: a menudo aparece en cálculos matemáticos, como: mejora de la precisión de los cálculos;
-int conversión enum: las enumeraciones se utilizan a menudo para ideogramas, El cálculo real sigue siendo el tipo int;
-int y conversión de puntero: al intentar calcular la ubicación de una variable miembro en el espacio de memoria del objeto en función del bit de desplazamiento, el puntero debe convertirse en un número entero para el cálculo. Cuando se calcula la posición de la variable (tipo entero), debe convertirse a un tipo de puntero.
-Punteros con tipo y punteros sin tipo:
-Convertir datos de diferentes longitudes: el problema de interceptar datos;
-Conversión de puntero de clase con herencia: se usa principalmente en escenarios polimórficos;
-Conversión de puntero de clase sin herencia: no es particularmente común
Al probar las condiciones anteriores, tendremos los siguientes problemas:
1. Error del compilador. Esto se debe a que la gramática estipula que este uso es ilegal. Por lo tanto, cuando el compilador compila el código, considera que este comportamiento es ilegal y finaliza el proceso posterior.
2. Ocurrió un error durante la operación. Esto se debe a que es gramaticalmente legal, pero no es razonable en tiempo de ejecución.
A continuación, hablamos principalmente de la diferencia entre const_cast, static_cast, dynamic_cast y reinterpret_cast cuatro tipos de coerción:
1. static_cast
Es el tipo de operador de conversión más utilizado, como se muestra a continuación:
int i;
float f = 3.28;
i = static_cast<int>(f);2. const_cast
Ver que const no debe considerarse como una cuantificación de su longitud, sino por el contrario; su función es eliminar el atributo const de la variable y convertir el puntero de tipo const en puntero de tipo no const; como se muestra a continuación:
const int *fun(int a, int b){}
int const_cast<int *> (fun(1, 2));3. dynamic_cast
Se usa principalmente para verificar si la conversión de tipos cumple con la seguridad de tipos en tiempo de ejecución, pero solo es legal cuando se usa en tipos polimórficos, es decir, hay al menos un virtual en la clase.
4. reinterpret_cast
El significado chino de reinterpretar es "reinterpretar", mientras que la forma binaria de los datos representados en el hot interpret_cast se reinterpreta, pero el valor binario no cambiará. Como sigue:
int i;
char *ptr = "I Love You!!!";
int i = reinterpret_cast<int>(ptr);El siguiente código reemplaza los casos anteriores:
//指针转换整型
int a = dynamic_cast<int>(int *p);
//整型转换指针
int *p = dynamic_cast<int *>(int a);
//整型转换浮点型
float a = dynamic_cast<float>(int a);
//浮点型转换整型
int a = dynamic_cast<int>(float);
//类型指针转换无类型指针
void *p = dynamic_cast<void *>(int *p1);
//无类型指针转换类型指针
int *p = dynamic_cast<int *>(void *p);
//整型转换枚举
TYPE t = dynamic_cast<TYPE>(int a);
//枚举转换整型
int a = dynamic_cast<int>(TYPE t);
//无类型指针转换整型
int a = dynamic_cast<int>(void *p);
//无类型指针转换其他指针
Other *p = dynamic_cast<Other *>(void *pv);