Re: Foward decleration casting craziness
speedplane wrote:
I just found a bug in a very well known compiler and I was
wondering if others have found the same problem. Consider the
code snippet
class C; // Foward decleration
class A {
public:
// Here we cast to C but we don't know how to cast an A to
C* getAasC{ return (C*)this; };C
int a;
};
Note that this code will compile (in my compiler at least)
even though it does not know how to cast an A to a C.
Historical reasons. The compiler thinks it knows, even though
it doesn't.
This is a very good example of why the new casts were added to
the language. You're code uses a C-style cast, which can mean
many different things. Unless the compiler has actually seen
the definition of C, and knows that it should interpret the C
style cast as a static_cast, it supposes that a reinterpret_cast
is meant.
In all cases where the target of a cast is a pointer or a
reference, only a new style cast should be used, to tell the
compiler what type of cast you want. Then, if the compiler
doesn't have the information to do the type of cast you want, or
the cast isn't legal, it will output an error message, rather
than doing something else that you didn't want. (I sort of
favor new style casts in most cases, but when pointers or
references are involved, it's no longer a question of style or
personal preferences---only new style casts are acceptable.
Precisely because the C style cast is ambiguous.)
In another file say we define
C:
class B {
public:
int b;
};
class C : public B, A {
public;
int c;
}
In the first code snippet, the compiler does not know how to
cast an A to a C.
No. In the first code snippet, you told the compiler to cast an
A to a C however it felt like. The compiler didn't know how to
do a static_cast, so it did a reinterpret_cast. Had you told it
to do a static_cast, it would have complained.
Therefore it does a reinterpret cast instead of a static cast.
As the standard says it should.
The new style casts were added for a reason. Use them.
Consider the following code:
A * a = new C();
a->a = 50;
printf("A: %d, C: %d", a->a, a->getAasC()->c)
Depending on how you compiler does the reinterpret cast the above will
either segfault or print:
A: 50, C: 50
My compiler didn't even give me a warning!
G++ will warn if the proper options are given. (The problem is
that it then also warns in cases where the C style cast is not
so problematic; where it can only have one meaning.)
I think it should give you an error if you try to cast
something and it doesn't know how to do the cast.
You said you didn't care how it casted.
Has anyone else run into something like this?
I used to run into it all the time. On one project, for various
reasons, we had a very complex inheritance hierarchy. And a
slight change in it sometimes meant that a static_cast suddenly
(and silently) became a reinterpret_cast.
Any code review which allows a C style cast of a pointer or
reference to pass isn't doing its job.
--
James Kanze kanze.james@neuf.fr
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]