C++ 内存::dynamic_pointer_cast

一种称为强制转换的操作符将数据从一种类型转换为另一种类型。C++ 中的动态强制转换主要用于运行时安全的向下转换。动态转换要起作用，基类中需要有一个虚函数。只有多态基类才能使用动态转换，因为它们使用这些数据来确定安全的向下转换。

语法

以下是 C++ Memory::dynamic_pointer_cast 的语法：

shared_ptr<T> dynamic_pointer_cast (const shared_ptr<U>& sp) noexcept;

参数

sp − 这是一个共享指针。

示例 1

让我们来看下面的例子，我们将执行 dynamic_pointer_cast 并获取输出。

#include <iostream>
#include <exception>
using namespace std;
class Base {
   virtual void dummy() {}
};
class Derived: public Base {
   int a;
};
int main (){
   try {
      Base * pba = new Derived;
      Base * pbb = new Base;
      Derived * pd;
      pd = dynamic_cast<Derived*>(pba);
      if (pd==0) cout << "Welcome \n";
         pd = dynamic_cast<Derived*>(pbb);
      if (pd==0) cout << "TutorialsPoint\n";
   } catch (exception& e) {
      cout << "Exception: " << e.what();
   }
   return 0;
}

输出

让我们编译并运行上面的程序，这将产生以下结果：

TutorialsPoint

示例 2

考虑下面的例子，其中 dynamic_pointer_cast 在类层次结构中向下/横向转换。

#include <iostream>
#include <memory>
class Base {
   public:
      int a;
      virtual void f() const {
         std::cout << "Welcome To\n";
      }
      virtual ~Base() {}
};

class Derived : public Base {
   public:
      void f() const override {
         std::cout << "TutoriaslPoint\n";
      }
      ~Derived() {}
};
int main(){
   auto basePtr = std::make_shared<Base>();
   std::cout << "Base pointer: ";
   basePtr->f();
   auto derivedPtr = std::make_shared<Derived>();
   std::cout << "Derived pointer: ";
   derivedPtr->f();
   basePtr = std::static_pointer_cast<Base>(derivedPtr);
   std::cout << "Base pointer to derived : ";
   basePtr->f();
   auto downcastedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
   if (downcastedPtr) {
      std::cout << "Downcasted pointer : ";
      downcastedPtr->f();
   }
}

输出

运行上述代码后，它将显示如下输出：

Base pointer: Welcome To
Derived pointer: TutoriaslPoint
Base pointer to derived : TutoriaslPoint
Downcasted pointer : TutoriaslPoint

示例 3

在下面的例子中，我们将使用 dynamic_pointer_cast 并静态和动态地获取输出。

#include <iostream>
#include <memory>
struct A {
   static const char* static_type;
   const char* dynamic_type;
   A(){
      dynamic_type = static_type;
   }
};
struct B: A {
   static const char* static_type;
   B(){
      dynamic_type = static_type;
   }
};
const char* A::static_type = "Hello";
const char* B::static_type = "Welcome";
int main (){
   std::shared_ptr<A> Result;
   std::shared_ptr<B> bar;
   bar = std::make_shared<B>();
   Result = std::dynamic_pointer_cast<A>(bar);
   std::cout << "Result in static  type: " << Result->static_type << '\n';
   std::cout << "Result in dynamic type: " << Result->dynamic_type << '\n';
   return 0;
}

输出

代码执行后，将生成如下所示的输出：

Result in static  type: Hello
Result in dynamic type: Welcome