Nur zum Umwerfen

Question

Wir alle wissen, dass C-Style-Casts in C++ als böse angesehen werden. Aus diesem Grund werden sie durch const_cast<>, static_cast<> und dynamic_cast<> ersetzt, um ein gezielteres Casting zu ermöglichen, so dass der Programmierer nur die beabsichtigten Konvertierungsklassen zulässt. So weit, ist es gut.

Jedoch scheint es keine eingebaute Syntax zu sein eine explizite upcast auszuführen: A bedeutet die ansonsten implizite Umwandlung in Base& baseRef = derived explizit ohne dass die umgekehrten auszuführen.

Während ich weiß, dass dies eine ziemlich kleine Ecke Fall ist (die meiste Zeit die impliziten Konvertierungen funktionieren gut), habe ich mich gefragt, welche Techniken verfügbar sind, um eine solche Umwandlung in Benutzercode zu implementieren. Ich war jedoch nach dem Vorbild der

template<class T> 
class upcast { 
    public: 
     template<class U, typename = typename std::enable_if<std::is_convertible<U, T>::value>::type> 
     upcast(U value) : value(value) {} 
     operator T() { return value; } 
    private: 
     T value; 
}; 

über etwas nachzudenken, die zu kompliziert scheint gut zu sein, und da ich kein Experte in Template-Metaprogrammierung bin, würde Ich mag fragen, ob es andere/bessere/einfachere Ansätze.

Answer 1

std::forward<T&> nur upcasts erlauben:

struct A {}; 
struct B : A {}; 
A a; 
B b; 
auto& x = std::forward<A&>(b); // OK 
auto& y = std::forward<B&>(a); // fails 
auto* px = std::forward<A*>(&b); // OK 
auto* py = std::forward<B*>(&a); // fails