【C++】7.1虚函数dynamic_cast运算符

  含有虚函数的继承环境中，对象指针之间的转换分为3种类型：

• 子类向基类的向上转换（隐式转换）
• 基类向子类的向下转换
• 横向转换

1. 隐式转换

  向上转换是一种隐式转换，可以直接转换，也可以使用dynamic_cast运算符。但是使用基类指针调用派生类中的未重写的父类成员函数时，会被编译器视为非法。

class A {
public:
  virtual void f() { std::cout << "run A::f" << std::endl; }
};
class B : public A {
public:
  void f() { std::cout << "run B::f" << std::endl; }
  void g() { std::cout << "run B::g" << std::endl; }
};
void test01() {
  B b;
  //隐式转换，下面两行是等价的
  A *pa = &b;
  A *pa_dc = dynamic_cast<A *>(&b);
  pa->f();    //正确，调用B的虚函数
  pa_dc->f(); //正确，调用B的虚函数
  // pa->g();    //错误，用基类的指针调用派生类独有的成员
}

2. 向下转换

  向下转换是一种强制转换，可以使用dynamic_cast来实现。基类对象指针转换成派生类对象指针。

class C {
  int x, y;

public:
  C(int i, int j) : x(i), y(j) {}
  virtual void Display() const {
    std::cout << "class C x = " << x << ", y = " << y << std::endl;
  }
};
class D : public C {
  int z;

public:
  D(int i, int j, int k) : C(i, j), z(k) {}
  virtual void Display() const {
    C::Display();
    std::cout << "class D z = " << z << std::endl;
  }
};
void test02() {
  C c(1, 2);
  D d(3, 4, 5);
  C *pc = &d;                    //正确，隐式向上转换
  pc->Display();                 // 正确，调用D的Display函数
  D *pd = dynamic_cast<D *>(&c); //不安全的转换
  if (pd == nullptr) {
    std::cout << "c dynamic_cast failed" << std::endl;
  } else {
    pd->Display(); // 正确，调用D的Display函数
  }

  C *pc1 = &d;                     //正确，隐式向上转换
  D *pd1 = dynamic_cast<D *>(pc1); //正确，使用dynamic_cast，指针转换一定能成功
  if (pd1 == nullptr) {
    std::cout << "pc1 dynamic_cast failed" << std::endl;
  } else {
    pd1->Display(); // 正确，调用D的Display函数
  }
}

class C x = 3, y = 4
class D z = 5
c dynamic_cast failed
class C x = 3, y = 4
class D z = 5

3. 横向转换

TODO
我还没有过这个语法的需求。。

原文地址：https://blog.csdn.net/qq_39400324/article/details/144310745

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！