casting a pointer in Run Time [non-trivial Scnerio]

Question

I have to fix a typical memory leak, Problem is like that :

typedef std::map<unsigned long,Response> mapType;
class Response
{
public:
 void *dataPtr;
 unsigned long tag;
}

class anyClass
{
 public::

  DataType x;
}

From client i am getting a map of Type mapType , Which has Response object as map->second , As Response object contain a void Pointer.

Please note : Response Class do not know what type of data has been set to void pointer, Also i can't modify Response class to do so , As it is a legacy code and has a great impact :(

Now using map->first ,that i call as Tag,

Using this tag at run time using this tag i come to know about a class anyClass.

Now Response::dataPtr is smae as anyClass::DataType

But:

as class anyClass is one out of N type, So anyClass::DataType differs for each class which i come to know only at runtime.

Please guide me how i can cast a void pointer to type same to anyClass::DataType and can free it

Answer 1

First, I don't know why do you need to cast these pointers to their original type if it is a memory leak issue. You can simply delete the void* pointer anywhere. Second, you can convert the pointer to a specific type with a simple conditional statement to some specific type compared to the tag, but you need to have the specific code for that pointer in the given context, so in this sense there is not enough information here to solve the problem.

However, if you have a certain behaviour for your responses, call it 'process', you can use inheritance with virtual function to bind the desired behaviour to your object. This is basically the definition of the virtual methods, so use them, even if you need to refactor the old code for this. If there is a problem with the object disposing then it is a matter of a virtual destructor, so the base class should define a virtual dtor, and the using the dynamic_cast(ptr) gives you some type safety at the conversion.

In this way, you don't need the 'tag' member, unless you would like to this by hand with a big 'switch' statement. In this case I can suggest to use crc calculation from the typeid(AnyClass).name() in the tag member.

-- EDIT: There is an other way to store these object without having this issue, I would say a boost::any or similar functionality could solve your problem. If you are storing the data's in a boost any instead of void* pointers you can change the legacy code with a minimal impact. If you delete an entry from the map, it will remove the boost::any's inner value. That should do the trick.

Answer 2

Given that you mention "legacy" code, but may have some freedom to modify, I would likely suggest that whatever interface provided you the map be extended to include a free-ing function.

Then it could apply the same type logic as when it created the object in the first place.

If that is impossible, then you will likely end up with a case statement and some re-interpret casts like the following pseudo-code:

  switch (type ) {
    case Type1:
      delete reinterpret_cast<Type1Class*>(ptr);
      break;
    case Type2:
      ...

Good Luck

Answer 3

If your tags are sequential you can build smth. like an array with either function objects or function pointers of their handlers:

template<class T>
void deleteType(void* p)
{
   delete reinterpret_cast<T*>(p);
}

typedef void (deletePtr)(void*);
deletePtr handlers_[] =
{ &deleteType<int> //means: accessed by tag with value 0
, &deleteType< vector<int> > // tag with value 1
, ...
};

//somewhere later:
handlers_[response->tag](response->dataPtr);

This solution requires you to know all types which are possibly stored in response.

If tags are not sequential, you will need to use a map or smth. similar, which involves non-constant complexity.

Hope that helps,
Ovanes

P.S. But if you decide to change the response take a look at boost::variant. Which is exactly what you need, if you were allowed to program generically ;)