Demonstration static_cast und Zweck davon?

Question

Ich versuche static_cast in Bezug auf Upcasting (Kind zu Eltern) zu verstehen. Es ergibt keinen Sinn für mich. Ich muss ein Kind zu einem Elternteil werfen und es demonstrieren. Wenn ich mir Code online anschaue und Bücher referenziere, ist das was ich habe.

Mustang *myMustang = new Mustang; 
Car *myCar = new Car; 

myMustang = static_cast<Mustang*>(myCar); 

Aber offen gesagt, es zeigt nichts. Ich habe keine Bestätigung, dass es sogar gegossen hat. Ich habe versucht, der Car-Klasse eine öffentliche Funktion hinzuzufügen und sie vom Kind aus anzurufen, aber ... es ist offensichtlich vererbt.

Dies bedeutet auch, ich sehe derzeit keinen Zweck in dieser Art von Upcasting.

Meine Frage ist, wie verifiziere ich das sogar gegossen und was ist der Zweck dieser Eingabe von Casting?

update: Die Antworten waren ein bisschen schwer zu folgen aufgrund der Tatsache, dass ich keine Erfahrung mit dieser Art von Casting habe und virtuelle Funktionen sind eine vage Erinnerung. Mein Freund konnte mir helfen. Unten ist der Code für den Fall, dass jemand das gleiche Problem hat.

class Car { 
    public: 
    virtual void Greeting() { cout << "I am a car." << endl; }; 
}; 

class Focus : public Car{ 
    public: 
    void FocusGreeting() { cout << "Hello, I am a Ford Focus." << endl; } 
}; 

class Mustang : public Car { 
    public: 
    virtual void Greeting() override { cout << "I am a Ford Mustang." << endl; } 
}; 

// in main 
Mustang* myMustang = new Mustang; 
Car *myCar = new Car; 

myCar->Greeting(); 
cout << "Now "; 
myCar = static_cast<Car*>(myMustang); 

myCar->Greeting(); 

Answer 1

Ein Beispiel für die Verwendung in der Muster CRTP:

#include <type_traits> 
// 
// the general concept of being able to accelerate 
template<class T> 
struct acceleratable 
{ 
    auto accelerate() { 
    static_assert(std::is_base_of<acceleratable<T>, T>::value, ""); 
    // turn this in to a T, since we know that *this really is a T 
    return static_cast<T*>(this)->do_accelerate(); 
    } 
}; 

// 
// something that implementes the concept of being able to accelerate 
struct car : acceleratable<car> 
{ 
private: 
    friend acceleratable<car>; 
    void do_accelerate() 
    { 
    // accelerate implementation here 
    } 
}; 

// 
// free function which accelerates anything that's acceleratable 
template<class Thing> 
auto accelerate(Thing& t) 
{ 
    t.accelerate(); 
} 

int main() 
{ 
    car c; 
    accelerate(c); 
} 

Answer 2

Ein weiteres nicht-triviale Anwendungsbeispiel ist die Typ-Löschungs:

class S { 
    using FN = void(*)(void*); 

    template<typename T> 
    static void invoke(void *ptr) { 
     static_cast<T*>(ptr)->foo(); 
    } 

public: 
    template<typename T> 
    static S create(T *t) { 
     S s; 
     s.ptr = t; 
     s.f = &invoke<T>; 
     return s; 
    } 

    void run() { 
     f(ptr); 
    } 

private: 
    void *ptr; 
    FN f; 
}; 

struct A { void foo() {} }; 
struct B { void foo() {} }; 

int main() { 
    A a; 
    B b; 

    S s1 = S::create(&a); 
    S s2 = S::create(&b); 

    s1.run(); 
    s2.run(); 
}