63.C++类型转换

1.显式类型转换

  类型转换(cast)是将一种数据类型转换成另一种数据类型。例如，如果将一个整型值赋给一个浮点类型的变量，编译器会暗地里将其转换成浮点类型。

  转换是非常有用的，但是它也会带来一些问题，比如在转换指针时，我们很可能将其转换成一个比它更大的类型，但这可能会破坏其他的数据。

  应该小心类型转换，因为转换也就相当于对编译器说：忘记类型检查，把它看做其他的类型。

  一般情况下，尽量少的去使用类型转换，除非用来解决非常特殊的问题。

无论什么原因，任何一个程序如果使用很多类型转换都值得怀疑。

  标准c++提供了一个显示的转换的语法，来替代旧的C风格的类型转换。

  使用C风格的强制转换可以把想要的任何东西转换成我们需要的类型。那为什么还需要一个新的C++类型的强制转换呢？

  新类型的强制转换可以提供更好的控制强制转换过程，允许控制各种不同种类的强制转换。C++风格的强制转换其他的好处是，它们能更清晰的表明它们要干什么。程序员只要扫一眼这样的代码，就能立即知道一个强制转换的目的。

//2023年3月10日19:52:46
#pragma warning(disable:4996)
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <string>
using namespace std;

//静态转换
//1.基础类型转换
void test01()
{
    char a = 'a';
    //char->double;
    //static_cast<目标类型>(待转类型)
    double d = static_cast<double>(a);

    //double d1 = (double)a;
}
//2.有层次关系的类的指针或引用转换
class Father
{

};
class Son :public Father
{

};

class Other
{

};
void test02()
{
    Father* f = NULL;
    Son* s = NULL;

    //向下转换，不安全
    static_cast<Son*>(f);
    //向上转换，安全
    Father* f1 = static_cast<Father*>(s);
    //没有继承关系的类之间的指针不能转换
    //Other* o = static_cast<Other*>(s);
}

//引用转换
void test03()
{
    Father f;
    Son s;

    Father& ref_f = f;
    Son& ref_s = s;

    //向上转换，安全
    static_cast<Father&>(ref_s);

    //向下转换，不安全
    static_cast<Son&>(ref_f);
}

//动态转换
void test04()
{
    //char a = 'a';
    //dynamic_cast<double>(a);//基础数据类型不能使用动态转换

    Father* f = NULL;
    Son* s = NULL;
    //向上，安全
    Father* f1 = dynamic_cast<Father*>(s);
    //向下，不安全，会检查
    //Son* s1 = dynamic_cast<Son *>(f);
}

class Father2
{
public:
    virtual void func() {};
};
class Son2 :public Father2
{
public:
    virtual void func() {};
};

//发生多态时，向下转换，动态转换就可以
void test05()
{
    Father2* f = new Son2;

    dynamic_cast<Son2*>(f);
}

//常量转换
void test06()
{
    const int* p = NULL;
    //const-->不带const
    int* newP = const_cast<int*>(p);

    int* pp = NULL;
    const int* newPP = const_cast<const int*>(pp);
}
//重新解释转换
void test07()
{
    int a = 10;
    int* p = reinterpret_cast<int*>(a);

    Father* f = NULL;
    Other* o = reinterpret_cast<Other*>(f);
}
int main()
{
    test05();
    system("pause");
    return EXIT_SUCCESS;
}

1.1静态转换(static_cast)

●用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。

▷进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；

▷进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。

●用于基本数据类型之间的转换，如把int转换成char，把char转换成int。这种转换的安全性也要开发人员来保证。

class Animal{};
class Dog : public Animal{};
class Other{};

//基础数据类型转换
void test01(){
	char a = 'a';
	double b = static_cast<double>(a);
}

//继承关系指针互相转换
void test02(){
	//继承关系指针转换
	Animal* animal01 = NULL;
	Dog* dog01 = NULL;
	//子类指针转成父类指针,安全
	Animal* animal02 = static_cast<Animal*>(dog01);
	//父类指针转成子类指针，不安全
	Dog* dog02 = static_cast<Dog*>(animal01);
}

//继承关系引用相互转换
void test03(){

	Animal ani_ref;
	Dog dog_ref;
	//继承关系指针转换
	Animal& animal01 = ani_ref;
	Dog& dog01 = dog_ref;
	//子类指针转成父类指针,安全
	Animal& animal02 = static_cast<Animal&>(dog01);
	//父类指针转成子类指针，不安全
	Dog& dog02 = static_cast<Dog&>(animal01);
}

//无继承关系指针转换
void test04(){
	
	Animal* animal01 = NULL;
	Other* other01 = NULL;

	//转换失败
	//Animal* animal02 = static_cast<Animal*>(other01);
}

1.2动态转换(dynamic_cast)

●dynamic_cast主要用于类层次间的上行转换和下行转换；

●在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；

●在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全；

class Animal {
public:
	virtual void ShowName() = 0;
};
class Dog : public Animal{
	virtual void ShowName(){
		cout << "I am a dog!" << endl;
	}
};
class Other {
public:
	void PrintSomething(){
		cout << "我是其他类!" << endl;
	}
};

//普通类型转换
void test01(){

	//不支持基础数据类型
	int a = 10;
	//double a = dynamic_cast<double>(a);
}

//继承关系指针
void test02(){

	Animal* animal01 = NULL;
	Dog* dog01 = new Dog;

	//子类指针转换成父类指针 可以
	Animal* animal02 = dynamic_cast<Animal*>(dog01);
	animal02->ShowName();
	//父类指针转换成子类指针 不可以
	//Dog* dog02 = dynamic_cast<Dog*>(animal01);
}

//继承关系引用
void test03(){

	Dog dog_ref;
	Dog& dog01 = dog_ref;

	//子类引用转换成父类引用 可以
	Animal& animal02 = dynamic_cast<Animal&>(dog01);
	animal02.ShowName();
}

//无继承关系指针转换
void test04(){
	
	Animal* animal01 = NULL;
	Other* other = NULL;

	//不可以
	//Animal* animal02 = dynamic_cast<Animal*>(other);
}

1.3常量转换(const_cast)

该运算符用来修改类型的const属性。。

●常量指针被转化成非常量指针，并且仍然指向原来的对象；

●常量引用被转换成非常量引用，并且仍然指向原来的对象；

 注意:不能直接对非指针和非引用的变量使用const_cast操作符去直接移除它的const。

//常量指针转换成非常量指针
void test01(){
	
	const int* p = NULL;
	int* np = const_cast<int*>(p);

	int* pp = NULL;
	const int* npp = const_cast<const int*>(pp);

	const int a = 10;  //不能对非指针或非引用进行转换
	//int b = const_cast<int>(a); }

//常量引用转换成非常量引用
void test02(){

int num = 10;
	int & refNum = num;

	const int& refNum2 = const_cast<const int&>(refNum);
	
}

1.4重新解释转换(reinterpret_cast)

  这是最不安全的一种转换机制，最有可能出问题。

  主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针.

2.隐式类型转换

2.1算数转换

类型所能表示的值的范围决定了转换的过程：

●当我们把个非布尔类型的算术值赋给布尔类型时，初始值为0则结果为false，否则结果为true。

●当我们把一个布尔值赋给非布尔类型时， 初始值为false则结果为0，初始值为true则结果为1。

●当我们把一个浮点数赋给整数类型时， 进行了近似处理。结果值将仅保留浮点数中小数点之前的部分。

●当我们把一个整数值赋给浮点类型时，小数部分记为0。如果该整数所占的空间超过了浮点类型的容量， 精度可能有损失。

●当我们赋给无符号类型一个超出它表示范围的值时，结果是初始值对无符号类型表示数值总数取模后的余数。例如，8比特大小的unsigned char可以表示0至255区间内的值， 如果我们赋了 个区间以外的值，则实际的结果是该值对256取模后所得的余数。 因此， 把－1赋给8比特大小的unsigned char 所得的结果 是255。

●当我们赋给带符号类型一个超出它表示范围的值时， 结果是未定义的(undefined)。此时， 程序可能继续工作、 可能崩溃， 也可能生成垃圾数据。

建议：避免无法预知和依赖于实现环境的行为

含有无符号类型的表达式

  尽管我们不会故意给无符号对象赋一个负值，却可能（特别容易）写出这么做的代码。例如，当一个算术表达式中既有无符号数又有int值时，那个int值就会转换成无符号数。把耳让转换成无符号数的过程和把int直接赋给无符号变址一样：

unsigned u = 10; 
int i= -42; 
std::cout << i + i << std::endl; // 输出-84
std::cout << u + i << std::endl;//如果int占32位，输出294967264

  当从无符号数中减去 一个值时，不管这个值是不是无符号数，我们都必须确保结果不能是一个负值：

unsigned u1 = 42, u2 = 10; 
std::cout << u1 -u2 << std::endl;//正确：检出32
std::cout << u2 -u1 << std::endl;//正确：不过，结果是取模后的值

  无符号数不会小于0这一事实同样关系到循环的写法。

  可能你会觉得反正也不打算输出负数，可以用无符号数来重写这个循环。然而，这个不经 意的改变却意味着死循环：

//错误：变量u永远也不会小于0'循环条件一直成立
for (unsigned u = 10; u >= O; --u)
std::cout << u << std::endl; 
//来看看当u等于0时发生了什么，这次迭代输出0，然后继续执行for语句里的表达式。

提示：切勿混用带符号类型和无符号类型

  如果表达式里既有带符号类型又有无符号类型，当带符号类型取值为负时会出现异常结果这是因为带符号数会自动地转换成无符号数。例如，在一个形如a*b的式子中，如果a= -1，b = 1，而且a和b都是int，则表达式的值显然为－1。然而，如果a是int，而b是unsigned，则结果须视在当前机器上int所占位数而定。在我们的环境里，结果是4294967295。