static_cast 및 목적을 설명 하시겠습니까?

Question

업 캐스팅 (부모에서 자식으로)과 관련하여 static_cast를 이해하려고합니다. 나에게 의미가 없다. 나는 아이를 부모에게 던지고 그것을 증명해야한다. 온라인에서 몇 가지 코드를 살펴보고 책을 참조하면 이것이 내가 가진 것입니다.

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

myMustang = static_cast<Mustang*>(myCar); 

하지만 솔직히 말해서 아무 것도 표시되지 않습니다. 나는 심지어 그것이 주조되었다는 어떠한 확인도하지 못했다. 나는 Car 클래스에 public 함수를 추가하려고 시도하고 자식으로부터 호출하도록했지만, 분명히 상속되었습니다.

이것은 또한 현재이 유형의 상향 캐스팅에 목적이 표시되지 않는다는 것을 의미합니다.

제 궁금한 점은이 사실을 캐스팅 한 것을 어떻게 확인할 수 있습니까? 캐스팅의 유형은 무엇입니까?

업데이트 :이 유형의 캐스팅에 대한 경험이없고 사실상의 기능이 모호한 사실로 인해 답변이 약간 어려웠습니다. 내 친구가 나를 도울 수있었습니다. 다음은 다른 누구도 동일한 문제가있는 경우의 코드입니다.

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

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

사용의 또 다른 사소 예이다 타입 소거 :

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(); 
}