reinterpret_cast en C++ | Tipo Operadores de fundición

reinterpret_cast es un tipo de operador de conversión utilizado en C++. 
 

• Se utiliza para convertir un puntero de algún tipo de datos en un puntero de otro tipo de datos, incluso si los tipos de datos antes y después de la conversión son diferentes.
• No verifica si el tipo de puntero y los datos señalados por el puntero son iguales o no.

Sintaxis: 
 

data_type *var_name = 
       reinterpret_cast <data_type *>(pointer_variable);

Tipo de retorno 
 

• No tiene ningún tipo de retorno. Simplemente convierte el tipo de puntero.

Parámetros 
 

• Solo toma un parámetro, es decir, la variable del puntero de origen (p en el ejemplo anterior).

// CPP program to demonstrate working of
// reinterpret_cast
#include <iostream>
using namespace std;
 
int main()
{
    int* p = new int(65);
    char* ch = reinterpret_cast<char*>(p);
    cout << *p << endl;
    cout << *ch << endl;
    cout << p << endl;
    cout << ch << endl;
    return 0;
}

65
A
0x1609c20
A

Propósito para usar reinterpret_cast 
 

1. reinterpret_cast es un tipo de operador de casting muy especial y peligroso. Y se sugiere usarlo usando el tipo de datos adecuado, es decir, (el tipo de datos del puntero debe ser el mismo que el tipo de datos original).
2. Puede encasillar cualquier puntero a cualquier otro tipo de datos.
3. Se utiliza cuando queremos trabajar con bits.
4. Si usamos este tipo de yeso entonces se convierte en un producto no portátil. Por lo tanto, se sugiere no utilizar este concepto a menos que sea necesario.
5. Solo se usa para encasillar cualquier puntero a su tipo original.
6. El valor booleano se convertirá en un valor entero, es decir, 0 para falso y 1 para verdadero.

// CPP code to illustrate using structure
#include <bits/stdc++.h>
using namespace std;
 
// creating structure mystruct
struct mystruct {
    int x;
    int y;
    char c;
    bool b;
};
 
int main()
{
    mystruct s;
 
    // Assigning values
    s.x = 5;
    s.y = 10;
    s.c = 'a';
    s.b = true;
 
    // data type must be same during casting
    // as that of original
 
    // converting the pointer of 's' to,
    // pointer of int type in 'p'.
    int* p = reinterpret_cast<int*>(&s);
 
    cout << sizeof(s) << endl;
 
    // printing the value currently pointed by *p
    cout << *p << endl;
 
    // incrementing the pointer by 1
    p++;
 
    // printing the next integer value
    cout << *p << endl;
 
    p++;
 
    // we are casting back char * pointed
    // by p using char *ch.
    char* ch = reinterpret_cast<char*>(p);
 
    // printing the character value
    // pointed by (*ch)
    cout << *ch << endl;
 
    ch++;
 
    /* since, (*ch) now points to boolean value,
    so it is required to access the value using
    same type conversion.so, we have used
    data type of *n to be bool. */
 
    bool* n = reinterpret_cast<bool*>(ch);
    cout << *n << endl;
 
    // we can also use this line of code to
    // print the value pointed by (*ch).
    cout << *(reinterpret_cast<bool*>(ch));
 
    return 0;
}

12
5
10
a
1
1

Programa 2 
 

// CPP code to illustrate the pointer reinterpret
#include <iostream>
using namespace std;
 
class A {
public:
    void fun_a()
    {
        cout << " In class A\n";
    }
};
 
class B {
public:
    void fun_b()
    {
        cout << " In class B\n";
    }
};
 
int main()
{
    // creating object of class B
    B* x = new B();
 
    // converting the pointer to object
    // referenced of class B to class A
    A* new_a = reinterpret_cast<A*>(x);
 
    // accessing the function of class A
    new_a->fun_a();
    return 0;
}

In class A

Enlace relacionado: 
https://www.geeksforgeeks.org/casting-operators-in-c-set-1-const_cast/  
https://stackoverflow.com/questions/573294/when-to-use-reinterpret-cast” rel =”noopener” target=”_blank  
http://forums.codeguru.com/showthread.php?482227-reinterpret_cast-lt-gt-and-where-can-it-be-used  
https://www.ibm.com /support/knowledgecenter/en/SSLTBW_2.3.0/com.ibm.zos.v2r3.cbclx01/keyword_reinterpret_cast.htm  
https://stackoverflow.com/questions/573294/when-to-use-reinterpret-cast