Conversión de tipos (C ++)

1. Introducción

El significado de la conversión de tipo es cambiar la forma en que se representa la variable cambiando el tipo de una variable a otro tipo.

Dos, conversión de tipo obligatoria de C ++

La coerción al estilo C no es segura.

Conversión de tipo forzada de C ++:

Se han agregado cuatro palabras clave static_cast, const_cast, reinterpret_cast y dynamic_cast al lenguaje C ++. Estas cuatro palabras clave se utilizan para la conversión de tipo forzada.
El nuevo tipo de conversión forzada puede proporcionar un mejor control sobre el proceso de conversión forzada, permitiendo el control de varios tipos de conversión forzada.
El estilo en C ++ es static_cast (contenido). El otro beneficio de las conversiones de estilo C ++ es que pueden indicar claramente lo que están haciendo. Siempre que el programador mire ese código, puede saber inmediatamente el propósito de una coacción.

Tres, introducción específica

1. static_cast: Conversión general, utilizada para la conversión coercitiva de tipos de datos, obligando a un tipo de datos a convertirse en otro tipo de datos.

	int a = 98;
	char c = static_cast<char>(a);
	cout << c << endl;// b

Puntero de tipo de datos básico, el puntero de objeto no se puede convertir.

	//基础数据类型指针
	int* p = NULL;
	char* sp = static_cast<char*>(p);//无效

	//对象指针
	Building* building = NULL;
	Animal* ani = static_cast<Animal*>(building);//无效

Puede convertir punteros o referencias con herencia.

	//父类指针转成子类指针
	Animal* ani = NULL;
	Cat* cat = static_cast<Cat*>(ani);
	//子类指针转成父类指针
	Cat* soncat = NULL;
	Animal* anifather = static_cast<Animal*>(soncat);

	//还有具有继承关系的指针或者引用
	Animal aniobj;
	Animal& aniref = aniobj;
	Cat& cat = static_cast<Cat&>(aniref);

	Cat catobj;
	Cat& catref = catobj;
	Animal& anifather2 = static_cast<Animal&>(catref);

2. dynamic_cast <type_id> (expresión), al convertir punteros o referencias con relación de herencia, el tipo de objeto se comprobará antes de la conversión y la conversión
de subtipo a tipo base puede fallar.

Los otros tres se completan en tiempo de compilación, dynamic_cast se procesa en tiempo de ejecución y la verificación de tipos se realiza en tiempo de ejecución.
No se puede utilizar para la coerción de tipos de datos básicos integrados .
```
int a = 10;
char c = dynamic_cast<char>(a);//无效
```
La conversión dynamic_cast devuelve un puntero o referencia a la clase si tiene éxito y NULL si falla la conversión.
Si usa dynamic_cast para la conversión, debe haber una función virtual en la clase base; de lo contrario, la compilación no pasará.

B中需要检测有虚函数的原因：类中存在虚函数，就说明它有想要让基类指针或引用指向派生类对象的情况，此时转换才有意义。这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表。
En la conversión de clases, los efectos de dynamic_cast y static_cast son los mismos cuando se realiza una conversión ascendente entre niveles de clase. Al realizar una conversión descendente, dynamic_cast tiene la función de verificación de tipo, que es más segura que static_cast.

Conversión ascendente, es decir, el puntero de subclase apunta al puntero principal (generalmente no hay problema), la memoria es grande y pequeña; conversión descendente, es decir, el puntero principal se convierte en el puntero de subclase, que no es seguro. El éxito de la conversión descendente también está relacionado con el tipo que se va a convertir, es decir, el tipo real del objeto al que apunta el puntero que se va a convertir debe ser el mismo que el tipo de objeto después de la conversión; de lo contrario, la conversión fallará. .

En C ++, la conversión de tipos en tiempo de compilación puede causar errores en tiempo de ejecución, especialmente cuando implica operaciones de puntero o referencia de objetos de clase. El operador Dynamic_cast puede probar las conversiones de tipos que pueden causar problemas en tiempo de ejecución.

	//非继承关系的指针
	Animal* ani = NULL;
	Building* building = dynamic_cast<Building*>(ani);//报错
	//具有继承关系指针
	Animal* ani = NULL;
	Cat* cat = dynamic_cast<Cat*>(ani);//报错  原因在于 dynamic做类型安全检查

	Cat* cat = NULL;
	Animal* ani = dynamic_cast<Animal*>(cat);

** 3, const_cast: ** el calificador const se usa generalmente para limitar la variable, se usa para indicar que el valor de la variable no se puede modificar, y const_cast se usa para forzar la eliminación de esta característica constante que no se puede modificar, pero necesita especial Tenga en cuenta que const_cast no se utiliza para eliminar la constancia de las variables, sino para eliminar la constancia de punteros o referencias a objetos constantes.El objeto que elimina la constancia debe ser punteros o referencias.

El puntero constante está obligado a ser un puntero no constante y aún apunta al objeto original;
Las referencias constantes están obligadas a ser referencias no constantes y seguir apuntando al objeto original;
Los objetos constantes se fuerzan a convertirse en objetos no constantes.

	//基础数据类型
	int a = 10;
	const int& b = a;	//b = 10;
	int& c = const_cast<int&>(b);
	c = 20;
	cout << "a:" << a << endl;//20
	cout << "b:" << b << endl;//20
	cout << "c:" << c << endl;//20

	const int a = 10;
	const int& pp = a;
	int& cc = const_cast<int&>(pp);
	cc = 100;
	

	//指针   增加或者去除变量的const性
	const int* p = NULL;
	int* p2 = const_cast<int*>(p);

	int* p3 = NULL;
	const int* p4 = const_cast<const int*>(p3);

4 、 reinterpret_cast用法： reinterpret_cast <type_id> (expresión)

Hay tres propósitos principales de reinterpret_cast para la conversión forzada:

Cambiar el tipo de puntero o referencia,
Convierta el puntero o la referencia en un número entero de longitud suficiente,
Convierta un tipo integral en un puntero o tipo de referencia.

El identificador de tipo debe ser un puntero, referencia, tipo aritmético, puntero de función o puntero de miembro.

Puede convertir un puntero en un número entero y también puede convertir un número entero en un puntero (primero convierta un puntero en un número entero, después de convertir el número entero en un puntero del tipo original, también puede obtener el valor del puntero original).

El proceso de conversión forzada cuando se usa reinterpret_cast es solo una copia de bits, por lo que debe tener especial cuidado durante el uso.

	//1. 无关的指针类型都可以进行转换
	Building* building = NULL;
	Animal* ani = reinterpret_cast<Animal*>(building);

	//2. 函数指针转换
	FUNC1 func1;
	FUNC2 func2 = reinterpret_cast<FUNC2>(func1);

4. Conclusión

Debe conocer claramente la variable a transformar, qué tipo era antes de la transformación, qué tipo era después de la transformación y cuáles son las consecuencias después de la transformación.
En general, no se recomienda utilizar la conversión de tipos para evitar la conversión de tipos.