Los operadores de conversión se utilizan para la conversión de tipos en C++. Se utilizan para convertir un tipo de datos a otro. C++ admite cuatro tipos de conversiones:

1. transmisión_estática
2. transmisión_dinámica
3. const_cast
4. reinterpretar_cast

1. transmisión_estática

El transmisión_estática El operador es el operador de conversión más utilizado en C++. Realiza conversión de tipos en tiempo de compilación y se utiliza principalmente para conversiones explícitas que el compilador considera seguras.

Sintaxis de static_cast

  static_cast   <  new_type>(expresión);>

dónde,

• expresión: Datos a convertir.
• nuevo tipo: Tipo de expresión deseado

static_cast se puede utilizar para convertir entre tipos relacionados, como tipos numéricos o punteros en la misma jerarquía de herencia.

Ejemplo de static_cast

// C++ program to illustrate the static_cast #include  #include  using namespace std; int main() { int num = 10; // converting int to double double numDouble = static_cast(núm); //imprimiendo el tipo de datos cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(núm)).nombre()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>

i d d>

En este ejemplo, hemos incluido el tipoinfo biblioteca para que podamos usar ID de tipo() función para comprobar el tipo de datos. Hemos definido una variable entera 'num' y la convertimos en doble usando static_cast. Después de eso, imprimimos los tipos de datos de las variables y pasamos static_cast(núm) en ID de tipo() función para comprobar su tipo de datos. podemos ver que la salida i, d, d se imprime donde 'i' denota entero y 'd' denota doble .

2. transmisión_dinámica

El transmisión_dinámica El operador se utiliza principalmente para realizar downcasting (convertir un puntero/referencia de una clase base en una clase derivada). Garantiza la seguridad de tipos al realizar una verificación en tiempo de ejecución para verificar la validez de la conversión.

procesamiento de piratería

Sintaxis de Dynamic_cast

  dynamic_cast   <  new_type>(expresión);>

Si la conversión no es posible, transmisión_dinámica devuelve un puntero nulo (para conversiones de puntero) o lanza un excepción bad_cast (para conversiones de referencia).

Ejemplo de transmisión_dinámica

// C++ program to illustrate the dynamic_cast #include  using namespace std; // Base Class class Animal { public: virtual void speak() const { cout << 'Animal speaks.' << endl; } }; // Derived Class class Dog : public Animal { public: void speak() const override { cout << 'Dog barks.' << endl; } }; // Derived Class class Cat : public Animal { public: void speak() const override { cout << 'Cat meows.' << endl; } }; int main() { // base class pointer to derived class object Animal* animalPtr = new Dog(); // downcasting Dog* dogPtr = dynamic_cast(animalPtr); // comprobando si el encasillamiento es exitoso if (dogPtr) { dogPtr->speak(); } más { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(animalPtr); if (catPtr) { catPtr->hablar(); } más { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>

Dog barks. Failed to cast to Cat.>

Explicación: La primera línea de salida se imprime porque el 'animalPtr' del 'Animal' El tipo se transmite correctamente al 'Perro' tipo y hablar() Se invoca la función de la clase Perro pero la conversión del 'Animal' escriba a 'Gato' el tipo falla porque 'animalPtr' apunta a un 'Perro' objeto por lo tanto, la conversión dinámica falla porque la conversión encasillada no es segura.

3.const_cast

El const_cast El operador se utiliza para modificar el calificador constante o volátil de una variable. Permite a los programadores eliminar temporalmente la constancia de un objeto y realizar modificaciones. Se debe tener precaución al utilizar const_cast, ya que modificar un objeto constante puede provocar un comportamiento indefinido.

Sintaxis de const_cast

  const_cast   <  new_type>(expresión);>

Ejemplo de const_cast

// C++ program to illustrate the const_cast #include  using namespace std; int main() { const int number = 5; // Pointer to a const int const int* ptr = &number; // int* nonConstPtr = ptr; if we use this // instead of without using const_cast // we will get error of invalid conversion int* nonConstPtr = const_cast (ptr); *nonConstPtr = 10; corte<< 'Modified number: ' << *nonConstPtr; return 0; }>

Modified number: 10>

En el ejemplo anterior, hemos modificado el valor de tipo constante puntero cambiando su calificador de constante a no constante y luego imprimir el valor modificado.

4. reinterpretar_cast

El operador reinterpret_cast se utiliza para convertir el puntero a cualquier otro tipo de puntero. No realiza ninguna comprobación de si el puntero convertido es del mismo tipo o no.

Sintaxis de reinterpret_cast

  reinterpret_cast   <  new_type>(expresión);>

Ejemplo

// C++ program to illustrate the reinterpret_cast #include  using namespace std; int main() { int number = 10; // Store the address of number in numberPointer int* numberPointer = &number; // Reinterpreting the pointer as a char pointer char* charPointer = reinterpret_cast(númeroPuntero); //Imprimiendo las direcciones y valores de la memoria cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

En el ejemplo anterior, hemos definido una variable int 'número' y luego almacene la dirección del 'número' en 'númeroPuntero' del tipo int después de eso hemos convertido el 'númeroPuntero' del tipo int en el puntero char y luego guárdelo en 'charPointer' variable. Para verificar que hemos impreso la dirección tanto de numberPointer como de charPointer. Para imprimir la dirección almacenada en 'charPointer' reinterpretar_cast se utiliza para omitir el mecanismo de verificación de tipo de C++ y permitir que el puntero se imprima como una dirección de memoria genérica sin ninguna interpretación específica del tipo.

mejorado para bucle java

Nota: Por lo general, no se recomiendan const_cast y reinterpret_cast ya que son vulnerables a diferentes tipos de errores.