CODEWITHSUNDEEP
c++castingreinterpret-cast
Aman
Aman

Reputation: 339

Reinterpret cast to different type C++

While reading about Reinterpret cast, I was checking the following code.

class Type1 {
public:

    Type1() {
        a = "Class Type 1";
    }
    void get1()
    {
        std::cout << a;
    }
private:
    std::string a;
};

class Type2 {
public:
    
    Type2() {
        b = "class Type 2";
    }

    void get2()
    {
        std::cout << b;
    }
private:
    std::string b;
};

int main()
{
    
    Type1* type1 = new Type1();

    //converting Pointer
    Type2* type2 = reinterpret_cast<Type2*>(type1);

    // accessing the function of class A 
    type2->get2(); 
}

After running the following code it prints in console "Class Type 1"

Now type1 is pointer of type Type1 and i cast it to Type2 and store in type2. Now when i call type2->get2(); Is it printing the data member a of instantiated Type1 or compiler is dynamically changing function ?

Similarly in Following Code.

#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; 
}

How "In class A" is getting printed? since I instantiated Class B ?

Upvotes: 1

Views: 1098

Answers (2)

M.A
M.A

Reputation: 8

You used conversion reinterpret_cast in your code

This conversion only tells the compiler to consider pointing to a different type, regardless of the type. reinterpret_cast is the most illegal cast in C ++ that pays no attention to the destination and source data arrangement. And it just converts the value from one type to another.

Upvotes: -4

Bitwize
Bitwize

Reputation: 11210

What you are doing is undefined behavior. There is no correct answer to this.

It is illegal in C++ to use a pointer/reference resulting from a reinterpret_cast between two types of an unrelated hierarchy -- and so any code that generates from such cannot be reasoned about.

With undefined behavior, the compiler is free to do what it wishes with the invalid code. What you are experiencing may change between different compilers, optimization levels, and target architecture/system.

Upvotes: 9

Related Questions