Re: Implicit cast from derived to base == static_cast
abhay.burli@gmail.com wrote:
Hello,
Question-1:
Recently i was asked a question on the following lines...
1. class A {};
2. class B : public A {};
3. A *anA = 0;
4. B *aB = new B;
5. anA = aB;
6. anA = dynamic_cast<A*>(aB);
What is the difference between lines 5 and 6? Are they both same
semantically?
As you are casting from derived to base the compiler is not required to
delay the cast till runtime (it must work so there is no required
runtime check)
AFAIK, implicit cast in C++ has semantics of a static_cast. i.e. it is
done solely with compile-time information.
Yes, but sometimes a dynamic_cast<> can be handled entirely by the compiler.
Question-2:
Can i vindicate my understanding of Question-1 above with the
following code as proof!
<snip>
1. class A{
2. };
3. class B {
not that B is NOT derived from A.
4. public:
5. virtual ~B() {} // just to make this class polymorphic
6. };
7. int main(){
8. A *anA = 0;
9. B *aB = new B;
10. //anA = aB;
11. //anA = static_cast<A*>(aB);
Of course both these fail because there is no derived/base relationship
between A and B.
12. anA = dynamic_cast<A*>(aB);
However the compiler does not know that you will not elsewhere create a
relationship. e.g.:
class C: public A, public B {}
now there is a cross casting relationship between A and B which a
dynamic_cast can handle.
13. if(!anA)
14. std::cout<<"There you go!"<<std::endl;
15. return 0;
16. }
<\snip>
Lines 10 and 11 fail to compile. Line 12 suceeds. This is bcoz
dynamic_cast fails at runtime if done on unrelated classes!
static_cast will say the same but at compile time. So the deafult
casting also has semantics of a static_cast.
No, a static cast instructs the compiler to do it and that includes the
reverse direction of an implicit cast. I.e. implicit casts are only a
subset of static_cast<>.
Question-3:
What sections of the C++ standard deal with implicit casting and its
underlying implementation. Is it unspecified / implementation-defined?
I think it is scattered in several places but nonetheless it is fully
defined by the Standard and there is no latitude that I can recall for
an implementation to accept/reject an implicit cast.
Question-4:
In the context of the above question, is it possible to have a class
hierarchy, wherein a static_cast would succeed and a dynamic_cast
would fail for the same cast?
static downcasts will succeed and it is the motivation behind
dynamic_cast<> to provide a tool for safely down-casting.
--
Note that robinton.demon.co.uk addresses are no longer valid.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]