(re)implement dynamic_cast - c++

Question

I am working in an ARM7 embedded environment. The compiler I am using does not support the full C++ functionality. One feature it does NOT support is dynamic type casting.
Is there a way to implement dynamic_cast<>()?
I looked for code using Google, but no luck so far. Any ideas? Any links?
UPDATE:
Due to the comments... I'm using the ARM(R) IAR C/C++ Compiler.

Answer 1

dynamic_cast is useful when casting away from the base class, something to be done as little as possible.
Assuming the instances when you want to do this are limited, then a virtual function like GetMessageType() in a base class returning a different value in each derived class will let you know what to static_cast down to.

Answer 2

Take a look at the COM concepts -- objects there have a method to return a pointer to a specific interface that is selected by an identifier not built into the compiler (in COM's case, a UUID).
Depending on your application, a simple integer may do:
class castable {
virtual bool cast_to(int desttype) = 0;
};
class type1 : public castable { public: static int const type = 1; };
class type2 : public castable { public: static int const type = 2; };
class impl : public type1, public type2 {
virtual void *cast_to(int desttype) {
switch(desttype) {
case type1::type: return static_cast<type1 *>(this);
case type2::type: return static_cast<type2 *>(this);
default: return 0;
}
}
};
Then, if templates work correctly:
template<typename T> T my_dynamic_cast(castable *obj) {
return reinterpret_cast<T>(obj.cast_to(T::type));
}
You can then create objects normally, and cast between base class pointers:
impl im;
type1 *t1 = &im; // Implicit, as it is a base class
type2 *t2 = my_dynamic_cast<type2 *>(t1);
The only difficulty here is assigning the identifiers.

Answer 3

It really depends exactly how much of dynamic_cast functionality you need.
Most often, I see dynamic_cast used to perform a checked conversion: dynamic_cast<Derived*>(p) will return 0 if ultimately p real type is not Derived*...
... but even this is quite complicated:
What if p is really EvenMoreDerived and not just Derived ?
What is p inherits from Base multiple times ?
And it can get even more hairy:
static_cast is not able to cross virtual inheritance boundaries.
static_cast is not suitable for cross-branches conversions (you have to pass through the common ancestor)
static_cast cannot emulate the dynamic_cast<void*>() conversion.
So, if you want a simple barebone functionality of checked conversion up the inheritance tree in case of single inheritance without virtual thrown in, then you can actually implement it in user-land.
Otherwise, without RTTI support, you will be quite stuck.
Example of simple (dumb ?) implementation, beginning with the support from the class hierarchy:
class Base {
public:
typedef size_t ID;
virtual ID getID() const = 0;
protected:
static ID NextID() { static ID = 0; return ID++; }
// much more stuff
};
class Derived: public Base {
public:
static ID GetID() { static ID id = Base::NextID(); return id; }
virtual ID getID() const { return GetID(); }
};
We can leverage this with:
template <typename To>
To* dyn_cast(Base* b) {
if (b and b->getID() == To::GetID()) { return static_cast<To*>(b); }
return 0;
}
However, this only work for one level. So, if MoreDerived inherits from Derived then:
MoreDerived md;
assert(dyn_cast<Derived>(&md)); // failure ...
so it really gets tricky here.
A possible approach is to check from the top of the hierarchy, to the bottom.
class Base {
public:
template <typename To>
bool isa() const {
return this->match(To::GetID());
}
protected:
typedef size_t ID;
static ID NextID() { static ID id = 0; return id++; }
virtual bool match(ID) const { return false; }
};
class Derived: public Base {
public:
static ID GetID() { static ID id = NextID(); return id; }
protected:
virtual bool match(ID id) const { return id == GetID() || Base::match(id); }
};
class MostDerived: public Derived {
public:
static ID GetID() { static ID id = NextID(); return id; }
protected:
virtual bool match(ID id) const { return id == GetID() || Derived::match(id); }
};
Slightly more complex, but now:
template <typename To, typename From>
To const* dyn_cast(From const* f) {
if (f and f->template isa<To>()) { return static_cast<To const*>(f); }
return 0;
}
template <typename To, typename From>
To* dyn_cast(From* f) { return const_cast<To*>(dyn_cast<To>((From const*)f)); }
Test case:
int main() {
Derived derived; MostDerived mostDerived;
Base* d = &derived, * md = &mostDerived;
if (dyn_cast<Derived>(d)) { std::cout << "Derived -> Derived: ok\n"; }
else { std::cout << "Derived -> Derived: ko\n"; }
if (dyn_cast<MostDerived>(md)) { std::cout << "MostDerived -> MostDerived : ok\n"; }
else { std::cout << "MostDerived -> MostDerived : ko\n"; }
if (dyn_cast<Derived>(md)) { std::cout << "MostDerived -> Derived : ok\n"; }
else { std::cout << "MostDerived -> Derived : ko\n"; }
if (dyn_cast<MostDerived>(d)) { std::cout << "Derived -> MostDerived: ko\n"; }
else { std::cout << "Derived -> MostDerived: ok\n"; }
}
In action at ideone.
It is still very incomplete compared to a true dynamic_cast though. But it should cover most uses already.

Answer 4

Isn't it possible to just cast your pointer and start using it as the other type of object?
Foo* f = new Foo();
f.baz();
Bar* b = (Bar*)f;
b.bop();