Re: dynamic cast and derived classes
On Jul 28, 6:24 pm, Fred Mangusta <a...@bbb.it> wrote:
I have a class D1 derived from a base class B. I also have
some methods that accept either a pointer to D1 or a pointer
by reference to D1, as in
bool method1(D1* &d1_);
bool method2(D1* d1_);
//etc..
This worked well, until I discovered that I need to apply the
same methods on ANOTHER class derived from B, D2.
Since I was hoping it might be possible to use the same
methods I use for D1, (without creating duplicates) I
redefined all these methods in order that they will accept B
instead of D1. I thought this was a "more general" version of
these methods. So I had
bool method1(B* &b_);
bool method2(B* b_);
//etc..
The problem is, nothing works any more. The compiler complains if I pass
pointers of D1 or D2 to the "more generic" methods:
"no matching function for call to.."
Given a D1* or a D2*, you should be able to call method2. Or:
bool method1a( B* const& b ) ;
The reason you cannot call method1 is simple: it would require
binding the reference to a temporary, and since the reference is
to a non-const, presumably, you want to change it, and don't
want the results of the change to just disappear when the
temporary disappears.
Note that while a D isA B (up to a certain point, at least), a
D* is not a B*; the actual physical addresses may be different,
for example. A D* converts to a B*, but the result of the
conversion is a new, temporary pointer; in standard-speak, it is
NOT an lvalue.
I was considering the possibility of casting the D1/D2 pointer to a B
pointer through dynamic_cast, but I don't know if this is the correct
approach.
You can use static_cast as well, but since the conversion is
implicit anyway, it probably won't change anything. The problem
with method1 is that you are going to change the pointer. You'd
have to do something like:
D* original ;
B* tmp = original ;
method1( tmp ) ;
original = tmp ;
But why use a reference to a pointer anyway? Just have method1
take a pointer, and return a pointer (possibly null, if you want
to indicate some error condition). Something like:
B* method1b( B* ) ;
D* original ;
original = dynamic_cast< D* >( method1b( original ) ) ;
Will I still be able to manipulate D1-specific or D2-specific
features from within the method, if I pass a B-downcast
pointer to it?
If the function knows that you are only going to pass it a D1*,
and wants to use the D1 interface, you should declare it to take
a D1*. If it takes a B*, it should be able to do everything it
needs to do from the B interface.
What do you suggest to do?
What is the actual problem?
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34