爲什麼我們需要從基類型轉換爲派生類型並返回？

Question

我知道static_cast,dynamic_cast的存在。但我似乎無法找到一個具體的理由來說服自己，爲什麼要從基地派生或從基地派生，反之亦然？

代碼中的任何示例將不勝感激。

UPDATE

class Base 
{ 
    public: 
     void foo(); 
    private: 
     int _x; 
}; 

class Derive: Base 
{ 

}; 

Base *b = new Derive; //will b behave the same as if it's a Derive *? 
Derive *d = new Base; //I think d can't behave like a Derive * but Base *, right? 

Answer 1

實際上，這些演員陣容是代碼中不確定事件的明顯標記，因此在完美的世界中，您不應該使用它們。

但在某些情況下，他們是正確的工具。

對於的static_cast，基本上有兩種情況：

1.原始轉換。

當你確實需要一些整數在一個涉及浮點的演算中被處理。

float ratio = static_cast<float>(pixel_pos.x)/static_cast<float>(pixel_pos.y); // x and y are integers because pixel positions are absolute, but we need to get a floating point value here 

2.你有一些外部API的對象，你想要得到的特定的子類。

Thing* thing = factory.create("shoe"); // Even if I don't have it's real type, I know it's a shoe! 

Shoe* shoe = static_cast<Shoe*>(thing); // I need to use Shoe interface so lets cast it. 

如果你設計了系統，也許你可以做得更好，以避免演員。但是如果你沒有，並且你使用的API提供了基本類型作爲你使用它的一種方式，那麼你沒有別的選擇，只能投射。

static_cast也很有用，因爲它可以讓你在編譯時假設一些東西，所以你應該首先使用它，因爲它需要你確定你在做什麼。

3。你不知道什麼是對象的真實類型。

但是，在運行時需要知道實際類型時有一種特殊情況，因爲在另一次無法讓您知道它。典型的情況是，當你從外部系統接收某種物體並沒有對現實類型的對象

void on_something_happen(const Event& event) // callback triggered when an event occured in the library system this callback is plugged in 
{ 
    // here I want to manage two cases 
    ThingEvent* thing_event = dynamic_cast<ThingEvent*>(&event); 

    if(thing_event) 
    { 
     // do my thing 
    } 
    else 
    { 

     // ok this event HAVE TO be a FooEvent, otherwise this should crash 
     FooEvent& foo_event = dynamic_cast<FooEvent&>(event); 
     // do my thing 

    } 




} 

Answer 2

假設你有：

struct A { 
    int i; 
}; 

struct B : A { 
    char c; 
}; 

struct C : A { 
    double d; 
}; 

而且有些功能f()返回一個指針A，對此你不知道的定義。 當你這樣做：

A * a = f(); 

你怎麼知道你可以用a做什麼呢？根據上面的定義，每個B和C也是A，所以你知道如果a不爲空，你可以使用它的i數據成員沒有問題。另一方面，要使用c或d，您需要知道a的實際類型，並且這是通過dynamic_cast實現的。

讓我們假設你知道，實際上是一個指向B.你可以做的是：

B * b = dynamic_cast<B *>(a); 
if (b != 0) 
    b->c = 'd'; 

（是的，我知道我們假設你知道，但這樣的假設永遠永遠持有。 ..）

Answer 3

的典型情況的任何其他信息是需要的操作添加到現有的數據鍵入，但不能直接添加。

假設你有這樣的階級結構：

struct Base { 
    virtual doSomething() = 0; 
}; 

struct Derived1 : Base { 
    virtual doSomething(); 
    int x,y; 
}; 

struct Derived2 : Base { 
    virtual doSomething(); 
    float a,b; 
}; 

現在你寫傳遞一個基地&功能：

void f(Base& base); 

您希望能夠打印有關的基本信息，但無論出於何種原因，您都不允許修改Base來添加此操作（例如，它是商業圖書館的一部分）。在這種情況下，您可能需要這樣做：

void f(Base& base) 
{ 
    if (Derived1* p=dynamic_cast<Derived1*>(&base)) { 
    cout << "Derived1{" << p->x << "," << p->y << "}\n"; 
    } 
    else if (Derived2* p=dynamic_cast<Derived2*>(&base)) { 
    cout << "Derived2{" << p->a << "," << p->b << "}\n"; 
    } 
    else { 
    cout << "Unknown type\n"; 
    } 
} 

儘管這在面向對象的語言中通常被認爲是不好的風格。一個問題是，如果您將新類添加到層次結構中，那麼編譯器無法幫助您找到需要添加代碼以處理該新類實例操作的位置。