c++ reinterpret_cast类型转换简单实验

1.概要

c++提供如下几种转换，具体如下。
static_cast：用于非多态类型的转换。
dynamic_cast:用于多态类型的转换，主要用于向下类型转换（从基类指向派生类的指针/引用），会检查转换的有效性，如果转换不安全，则无法进行转换。
const_cast:用于去除const或volatile属性。
reinterpret_cat:允许所有指针转换为其他指针类型。并允许任何整型转换为任何指针类型反之亦然。

我这里只针对reinterpret_cat的转换进行实验，因为前三种用起来很简单，也很明确，似乎都没有什么明显的价值。
实验结果如下：
基本的结论就是，reinterpret_cat转换就是你如果想转，我就给你转，对象的赋值就是安装内存的面积赋值，其他的我都不管。至于有什么价值，就根据自己需要的场景使用吧，比如无法用面向对象来多态，那么用这个方法也许能起到一些特殊的效果。

2.代码

#include <iostream>
using namespace std;
 
//名称和变量的转换有什么差别
namespace test1 {
	class A
	{
	public:
		int a=0;
		void fun() {
			cout << "A fun a:" << a << "\n";
		}
	};
	class B
	{
	public:
		int a=1;
		void fun() {
			cout << "B fun a:" << a << "\n";
		}
	};
	void test() {
		cout << "------------------------------------------\n";
		A* a = new A();
		B* b = reinterpret_cast<B*>(a);
		b->fun();
		/*
		* 执行结果：使用A的变量，使用B的函数
		B fun a:0 
		Hello World!*/
	}
}
//不同的变量能否转换成功：可以匹配
namespace test2 {
	class A
	{
	public:
		int a = 2;
		void fun() {
			cout << "A fun a:" << a << "\n";
		}
	};
	class B
	{
	public:
		int b = 1;
		void fun() {
			cout << "B fun a:" << b << "\n";
		}
	};
	void test() {
		cout << "------------------------------------------\n";
		A* a = new A();
		B* b = reinterpret_cast<B*>(a);
		b->fun();
		/*
		* 执行结果：使用A的变量，使用B的函数
		* 虽然变量名，不同了，因为变量只有一个，且类型相同，那么可以匹配
		* B fun a:2 
		*/
	}
}
//变量类型不同是否匹配：不匹配
namespace test3 {
	class A
	{
	public:
		int a = 2;
		void fun() {
			double d = a;
			cout << "A fun a:" << d << "\n";
		}
	};
	class B
	{
	public:
		double b = 1;
		void fun() {
			cout << "B fun a:" << b << "\n";
		}
	};
	void test() {
		cout << "------------------------------------------\n";
		A* a = new A();
		a->fun();
		B* b = reinterpret_cast<B*>(a);
		b->fun();
		/*
		* 结果：
		* A fun a:2
		* B fun a:-7.84591e+298
		* 变量如果类型不同，就无法匹配，但是结果又不像是B类的b(1)
		* 那么问题的原因有可能是安装内存的区域拷贝数据了A拷贝给B所以造成B.b不是1
		*/
	}
}
namespace test4 {
	class A
	{
	public:
		char a = 1;
		char b = 2;
	};
	class B
	{
	public:
		char b[2] = { 3,4 };
		void fun() {
			for (size_t i = 0; i < 2; i++)
			{
				cout << (int)b[i];
			}
			cout << endl;
		}
	};
	void test() {
		cout << "------------------------------------------\n";
		A* a = new A();
		B b;
		b.fun();
		try
		{
			B* b = reinterpret_cast<B*>(a);
			b->fun();
		}
		catch (const std::exception& e)
		{
			cout << "yichang " << endl;
		}
		/*
		* 结果：
		* 34
		* 12
		* 从结果看，证实了上面的猜测，对象的变量是安装内存拷贝的
		* 那也就是从这个使用得到最终的结果：reinterpret_cast类中转换是安装内存的位置匹配的，和变量的名称类型都没有关系。只有内存的位置匹配，就可以安装这个原则拷贝
		*/
	}
}
//试一试A的内存多与B的情况
namespace test5 {
	class A
	{
	public:
		int a = 1;
		int b = 2;
	};
	class B
	{
	public:
		int a=3;
		void fun() {
			cout <<a<< endl;
		}
	};
	void test() {
		cout << "------------------------------------------\n";
		A* a = new A();
		B b;
		b.fun();
		try
		{
			B* b = reinterpret_cast<B*>(a);
			b->fun();
		}
		catch (const std::exception& e)
		{
			cout << "yichang " << endl;
		}
		/*
		* 结果：
		* 3
		* 1
		* 从结果看，B安装自己需要的内存位置有A的内存中获取
		*/
	}
}
namespace test6 {
	class A
	{
	public:
		int a = 1;
	};
	class B
	{
	public:
		int a = 2;
		int b = 3;
		void fun() {
			cout << a << endl;
			cout << b << endl;
		}
	};
	void test() {
		cout << "------------------------------------------\n";
		A* a = new A();
		B b;
		b.fun();
		try
		{
			B* b = reinterpret_cast<B*>(a);
			b->fun();
		}
		catch (const std::exception& e)
		{
			cout << "yichang " << endl;
		}
		/*
		* 结果：
		* 2
		* 3
		* 1 //由a获取
		* -33686019 //未知的值，不确定是由A获取的，还是默认的初始值。但这部分我认为如果保持B的默认值3应该是更好的
		* 从结果看，B安装自己需要的内存位置有A的内存中获取
		*/
	}
}
 
 
int main()
{
	test1::test();
	test2::test();
	test3::test();
	test4::test();
	test5::test();
	test6::test();
    std::cout << "Hello World!\n";
}

3.运行结果

------------------------------------------
B fun a:0
------------------------------------------
B fun a:2
------------------------------------------
A fun a:2
B fun a:-7.84591e+298
------------------------------------------
34
12
------------------------------------------
3
1
------------------------------------------
2
3
1
-33686019