This code compiles. Its obviously wrong because B can never be a WTF. Is there a way i can write the typecast so this is a compile time error?
class B{ public: virtual void abc(){} };
class D1 : public B{};
class WTF{ };
template<class T, class TT>
T DoSomething(TT o){
return dynamic_cast<T>(o);
}
B*Factory() { return new D1; }
int main(){
DoSomething<D1*, B*>(Factory());
DoSomething<WTF*, B*>(Factory());
}
No, you can't rewrite the cast to be a compiler time error, principally because your assertion that a B can never be a WTF is false.
E.g.
class Combine : public B, public WTF
{
};
int main()
{
Combine c;
std::cout << (void*)&c << '\n';
std::cout << (void*)dynamic_cast<WTF*>(&c) << '\n';
return 0;
}
static_cast and dynamic_cast are different in this particular context. The question creates D1, converts it to B, which is converted back into D1 (D1 -> B -> D1). This is the use case mentioned in the question. X -> B -> X. There is no mention of anything like X -> B -> Y, which would yield NULL if dynamic cast is used. So, in relation to the question, static cast and dynamic cast seem to be equivalent there. But maybe I am wrong about this.
–
Oct 16 '11 at 19:52
If your compiler/library support is behind the times and you don't have traits available, this will perform the simple check:
template<class T, class TT>
T DoSomething(TT o) {
enum { Concept_SimpleTypeRelationCheck = static_cast<T>(0) == static_cast<TT>(0) };
return dynamic_cast<T>(o);
}
With multiple inheritance, dynamic_cast<T>(o) could still fail (or succeed despite compilation error, as others have noted).
Note that this variant differs from the accepted answer (downcast via static_cast) in that its use of dynamic_cast preserves type safety when downcasting because it can return 0 if the type does not match the destination. static_cast is fine when upcasting through single inheritance hierarchies, but unsafe for downcasting (unless you have manually ensured correctness in each case).
There are two solutions to this problem, depending on what you want the code to be doing.
The first solution: Change the dynamic_cast into static_cast. This solution assumes that you never use class WTF in a class hierarchy with multiple inheritance. See below.
The second solution: You realize that C++ allows multiple inheritance. There is no way for you nor for the compiler to predict whether an arbitrary instance of WTF created sometime in the future will inherit from class B or not.
#include <stdio.h>
class B{ public: virtual void abc(){} };
class D1 : public B{};
class WTF{ };
class WTF_B : public WTF, public B {};
template<class T, class TT>
T DoSomething(TT o){
return dynamic_cast<T>(o);
}
B*Factory1() { return new D1; }
B*Factory2() { return new WTF_B; }
int main(){
printf("%p\n", DoSomething<D1*, B*>(Factory1()));
printf("%p\n", DoSomething<WTF*, B*>(Factory1()));
printf("%p\n", DoSomething<WTF*, B*>(Factory2()));
return 0;
}
The above source code can also be found here. Its output looks like this:
0x861a008
(nil)
0x861a028
In either case, the choice between solution 1 and solution 2 is yours - but the choice is yours only if you know what you are doing.
There is no way to make the compiler give an error about an impossible cast in this situation because it is not an impossible cast. There is the possibility that somewhere there is a class that has multiple inheritance to derive from both WTF and B.
