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