C++ - 类型转化

C++ 学习笔记

C++ 类型转化

概述

  • C++中的类型转换分为两种:

    • 隐式类型转换;
    • 显式类型转换。
  • 而对于隐式变换,在很多时候,不经意间就发生了,比如int类型和float类型相加时,int类型就会被隐式的转换位float类型,然后再进行相加运算。而关于隐式转换不是今天总结的重点,重点是显式转换。

  • 在标准C++中有四个类型转换符:static_cast、dynamic_cast、const_cast和reinterpret_cast;下面将对它们一一的进行总结。

static_cast

  • static_cast的转换格式:

    1
    static_cast <type-id> (expression)
  • 将expression转换为type-id类型,主要用于非多态类型之间的转换,不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用:

    • 1.基本数据类型之间的转换,如把int转换成char,把int转换成enum

    • 2.用于类层次结构中基类和子类之间指针或引用的转换。

      • 进行上行转换(把子类的指针或引用转换成基类表示)是安全的;
      • 进行下行转换(把基类指针或引用转换成子类指针或引用)时,由于没有动态类型检查,所以是不安全的。
    • 3.把void指针转换成目标类型的指针(不安全!!)

1
2
3
4
5
6
7
8
//隐式的类型转换
int firstnumber=10, secondnumber = 100 ;
double result=(double)firstnumber/secondnumber;
cout << result << endl;

//使用static_dynamic
double result2 = static_cast<double>(firstnumber)/static_cast<double> (secondnumber);
cout << result2 << endl;

dynamic_cast

  • dynamic_cast的转换格式:

    1
    dynamic_cast <type-id> (expression)
  • 将expression转换为type-id类型,type-id必须是类的指针、类的引用或者是void *;如果type-id是指针类型,那么expression也必须是一个指针;如果type-id是一个引用,那么expression也必须是一个引用。

  • dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换。在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast,因为类型提供了运行时信息。下面我将分别在以下的几种场合下进行dynamic_cast的使用总结:

最简单的上行(xing)转换

  • 比如B继承自A,B转换为A,进行上行转换时,是安全的,如下:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <iostream>
    using namespace std;
    class A
    {
    // ......
    };
    class B : public A
    {
    // ......
    };
    int main()
    {
    B *pB = new B;
    A *pA = dynamic_cast<A *>(pB); // Safe and will succeed
    }

多重继承之间的上行转换

  • C继承自B,B继承自A,这种多重继承的关系;但是,关系很明确,使用dynamic_cast进行转换时,也是很简单的:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class A
    {
    // ......
    };
    class B : public A
    {
    // ......
    };
    class C : public B
    {
    // ......
    };
    int main()
    {
    C *pC = new C;
    B *pB = dynamic_cast<B *>(pC); // OK
    A *pA = dynamic_cast<A *>(pC); // OK
    }
  • 而上述的转换,static_cast和dynamic_cast具有同样的效果。而这种上行转换,也被称为隐式转换;比如我们在定义变量时经常这么写:B *pB = new C;这和上面是一个道理的,只是多加了一个dynamic_cast转换符而已。

(这个真的是重点)如果expression是type-id的基类,使用dynamic_cast进行转换时,在运行时就会检查expression是否真正的指向一个type-id类型的对象,如果是,则能进行正确的转换,获得对应的值;否则返回NULL,如果是引用,则在运行时就会抛出异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class B
{
virtual void f(){};
};
class D : public B
{
virtual void f(){};
};
void main()
{
B* pb = new D; // unclear but ok
B* pb2 = new B;
D* pd = dynamic_cast<D*>(pb); // ok: pb actually points to a D
D* pd2 = dynamic_cast<D*>(pb2); // pb2 points to a B not a D, now pd2 is NULL
}

const_cast

  • 常量指针被转化成非常量指针,并且仍然指向原来的对象;

  • 常量引用被转换成非常量引用,并且仍然指向原来的对象;

  • const_cast的作用是用来改变表达式里面的常量性(const)或易变性(volatile)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #include <iostream>

    using std::cout;
    using std::endl;

    int main(void)
    {
    const int b = 10;
    //b = 11 报错,因为b是一个常量对象
    int * pc = const_cast<int *>(&b);
    *pc = 11;
    cout << "*pc = " << *pc << endl;//b原来地址的数据现在可由*pc来改变,即解除const
    cout << "b = " << b << endl; //b其实类似(编译器处理问题)#define b 10 不会变的

    return 0;
    }

欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论,也可以邮件至 qinhan_shu@163.com

文章标题:C++ - 类型转化

本文作者:QinHan

发布时间:2019-10-30, 08:03:00

最后更新:2020-02-20, 05:42:12

原始链接:https://qinhan.site/2019/10/30/cpp-cast/

版权声明: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。

目录
×

喜欢就点赞,疼爱就打赏