Question

My code was acting wonky and i was able to mini reproduce it with the code below. (codepad link)

From http://www.cppreference.com/wiki/keywords/dynamic_cast

If you attempt to cast to a pointer
type, and that type is not an actual
type of the argument object, then the
result of the cast will be NULL.

From my understanding this_test should be null. It isnt. How do i check if that dummy ptr is actually a ptr to a dummy object?

#include <ios>
struct Dummy{ virtual void dummyfn(){} };

int main(){
Dummy* this_test = dynamic_cast<Dummy*>((Dummy*)0x123);
//assert(this_test==0);
cout << std::hex << this_test<<endl;
return 0;
}

output:

0x123

Answer 1

The issue is that dynamic_cast expects either:

• a null pointer
• a valid pointer

Here you can only offer it garbage, so it is useless, and not the cast you want.

If you are getting a void*, then you can use reinterpret_cast (better than a C-cast, because more visible) to cast it into another type:

void* p = 0x123;
Dummy* dummy = reinterpret_cast<Dummy*>(p);

Note: the presence or absence of virtual methods goes unnoticed here

---

EDIT: if you can modify the objects being passed…

Then try to use a common base class:

struct Base: private boost::noncopyable { virtual ~Base() = 0 }; Base::~Base() {}

And define the following helpers:

template <typename T>
void* to_void(T* t) {
  Base* base = t;
  return reinterpret_cast<void*>(base);
}

template <typename T>
T* from_void(void* p) {
  Base* base = reinterpret_cast<Base*>(p);
  return dynamic_cast<T*>(base);
}

The former is extremely important because of the possible pointer adjustment (which will probably only occur in the case of Multiple Inheritance).

Note: it’s possible to use a fast_cast here if you don’t use virtual inheritance or other RTTI stuff

template <typename T, typename U>
T* fast_cast(U* u) {
#ifdef NDEBUG
  return static_cast<T*>(u);
#else
  return dynamic_cast<T*>(u);
#endif
}

---

If this is not possible the following solutions are possible, but they are going to feel hacky I fear.

Since dynamic_cast is not going to work properly here, you have to actually come up with your own type checking mechanism.

One method could be to use a “repository” in which you register the void* pointers you get, and the associated type_info object.

typedef std::map<void*, std::type_info const*> Repository;

template <typename Dest>
Dest* dynamic_check(void* p, Repository const& rep) {
  Repository::const_iterator it = rep.find(p);
  assert(it != rep.end() && "dynamic_check: no such entry");

  assert(typeid(Dest) == *(it->second) && "dynamic_check: wrong type");

  return reinterpret_cast<Dest*>(p);
}

If this is not possible, then you could hack the C++ object model to your advantage. If you know that the object has at least one virtual method, then it necessarily has a virtual pointer on all compilers I know (VS, gcc, clang), and this pointer is the first 4/8 bytes of the object.

inline void* virtual_pointer(void* p) {
  assert(p != 0 && "virtual_pointer: null");
  return reinterpret_cast<void*>(*p);
}

template <typename T>
void* virtual_pointer(T const& t) {
  return virtual_pointer(reinterpret_cast<void*>(&t));
}

template <typename T>
void* virtual_pointer() {
  static void* pointer = virtual_pointer(T());
  return pointer;
}


template <typename Dest>
Dest* dynamic_check(void* p) {
  assert(virtual_pointer<Dest>() == virtual_pointer(p));
  return reinterpret_cast<Dest*>(p);
}

Note: both solutions suffer from the same shortcoming, they will only work if you precise the exact type (well, you could get away with it as long as two types share the same virtual table, which happens if a derived class does not override any virtual method, including the destructor).

This is far from the power of a true dynamic_cast.