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