【C++】听说了吗，C++引入了四种强制类型转换

目录

• 一、类型转换
• • 1、C语言中的类型转换
  • 2、C++中的类型转换
  • 3、C语言类型转换的缺陷
  • 4、C++中的四种强制类型转换
  • • 4.1 static_cast
    • 4.2 reinterpret_cast
    • 4.3 const_cast
    • 4.4 dynamic_cast

      ---

      一、类型转换

      1、C语言中的类型转换

      如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与

      接收返回值类型不一致时，就需要发生类型转化，转换的前提是类型之间有一定的关联。

      • 隐式类型转换：编译器自动进行，比如整形家族（int、char、unsigned int）/ 整型和浮点数
      • 强制类型转换：我们自己处理，比如整形和指针、指针之间

        int main()
        {
        	int i = 1;
        	// 隐式类型转换
        	double d = i;
        	int* p = &i;
        	// 显示的强制类型转换
        	int address = (int)p;
        	return 0;
        }
        

        ---

        2、C++中的类型转换

        上面举的例子都是内置类型之间，而内置类型和自定义类型之间、自定义类型和自定义类型之间都是可以通过一定的方式互相转换的。

        | 内置类型和自定义类型之间：

        在前面的学习中我们经常说：单参数构造函数支持隐式类型转换，多参数也可以通过加{}进行隐式类型转换。

        class A
        {
        public:
        	A(int a)
        		:_a1(a)
        		,_a2(a)
        	{}
        	A(int a1, int a2)
        		:_a1(a1)
        		,_a2(a2)
        	{}
        private:
        	int _a1;
        	int _a2;
        };
        int main()
        {
        	string s("Are you ok?");//隐式类型转换
        	A a1(1);//借助构造函数完成类型转换
        	A a2({ 1, 2 });
        	return 0;
        }
        

        • C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数
        • 构造函数前加explicit就不再支持隐式类型转换（但是还可以强转）

          而自定义类型转换为内置类型需要通过下面这个函数：

          operator int()
          {
          	//...
          }
          

          • 这个函数没有返回类型，但是有返回值
          • 函数前加explicit就不再支持隐式类型转换（但是还可以强转）

            class A
            {
            public:
            	A(int a)
            		:_a1(a)
            		,_a2(a)
            	{}
            	A(int a1, int a2)
            		:_a1(a1)
            		,_a2(a2)
            	{}
            	operator int()
            	{
            		return _a1 + _a2;
            	}
            private:
            	int _a1;
            	int _a2;
            };
            int main()
            {
            	string s("Are you ok?");//隐式类型转换
            	A a1(1);//借助构造函数完成类型转换
            	A a2({ 1, 2 });
            	int x = a1;
            	int y = a2;
            	cout 
            public:
            	A(int a)
            		:_a1(a)
            		,_a2(a)
            	{}
            	A(int a1, int a2)
            		:_a1(a1)
            		,_a2(a2)
            	{}
            	operator int()
            	{
            		return _a1 + _a2;
            	}
            	int get() const
            	{
            		return _a1 + _a2;
            	}
            private:
            	int _a1;
            	int _a2;
            };
            class B
            {
            public:
            	B(int b)
            		:_b(b)
            	{}
            	B(const A& aa)
            		:_b(aa.get())
            	{}
            private:
            	int _b;
            };
            int main()
            {
            	A aa(1);
            	B bb(2);
            	bb = aa;//这里走了B的拷贝构造
            	return 0;
            }
            }
            //...
            
            	double d = 3.14;
            	int a = static_cast
            	double d = 3.14;
            	int a = static_cast
            	const int a = 2;
            	int* p = const_cast
            public:
            	virtual void f() {}
            };
            class B : public A
            {};
            void fun(A* pa)
            {
            	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
            	B* pb1 = static_cast
            	A a;
            	B b;
            	fun(&a);
            	fun(&b);
            	return 0;
            }