Warum kann der Compiler den Typparameter von static_cast nicht (oder nicht) ableiten?

Question

Ich habe einig (legacy) Code, der wie folgt aussieht: hier

void castFoo(string type, void* foo) { 
    FooA* foo_a = NULL; 
    FooB* foo_b = NULL; 

    if (type == "A") { 
    foo_a = static_cast<FooA*>(foo); 
    } else { 
    foo_b = static_cast<FooB*>(foo); 
    } 

    // now do things with one of the two foo's 
} 

Dies ist sehr alter Code und ich weiß, dass dies ist eine schreckliche Art und Weise, die Art von Downcasting zu tun, was los ist. Aber es hat mich neugierig gemacht: Warum kann ich das nicht so schreiben?

if (type == "A") { 
    foo_a = static_cast(foo); 
    } else { 
    foo_b = static_cast(foo); 
    } 

es ist sicherlich eindeutig an den Compiler, und es sieht aus wie eine normale Vorlage Argument Abzug in einer Funktion zu mir. Warum wird die Typabrechnung hier nicht vorgenommen?

Answer 1

Statische Besetzung ist gefährlich. In diesem Fall muss das Gießen nach/von void genau denselben Typ haben.

Implizite typimg würde Codeänderungen ermöglichen, die nicht direkt an die Umwandlungen angrenzen, um die beiden Umwandlungen zu einem undefinierten Verhalten zu veranlassen.

Sie können Code machen, der das tut, was Sie wollen, so schlecht wie es ist.

template<class V> 
struct implicit_static_cast_t{ 
    V v; 
    template<class T> 
    operator T()&&{ 
    return static_cast<T>(std::forward<V>(v)); 
    } 
}; 

template<class In> 
implicit_static_cast_t<In> 
auto_static_cast(In&& in){ 
    return {std::forward<In>(in)}; 
} 

Jetzt auto_static_cast verhält sich wie Sie wollen static_cast verhält sich wie.