Casting void *user_data to object

Question

how do I cast void *something to an object in standard C++? Specifically I want want to cast void *userdata to std::map<String, void*>

Is this possible? I am trying:

//void *user_data is a parameter of this function (callback)
std::map <String, void*> user_data_n; //this line is ok
user_data_n = static_cast<std::map<String, void *>>(*user_data); //I get the errors here.

ERRORs:

Spurious '>>' user '>' to terminate a template argument list
Expected '>' before '(' token
'void *' is not a pointer-to-object type

or is there a better way to carry information about the caller object and some other parameters I can pass to void *user_data?

UPDATE:

Ass suggested by @aaa carp I changed >> to > > and the first two errors were solved. The last is strange, Why do I get that kind of message when casting it here and not when putting that object when setting the callback?

std::map<String, void*> user_data_h;
user_data_h["Object"] = this; //this is a MainController object
user_data_h["h"] = h; //h was defined as int *h
createTrackbar("trackbar_H", winName, h, 255, trackbar_handler, &user_data_h);

where createTrackbar is defined as:

int createTrackbar( const string& trackbarname, const string& winname,
int* value, int count, TrackbarCallback onChange, void* userdata);

UPDATE2:

doing this solved my problem but following the same approach, why I still get error when trying to cast objects contained in my map object?

void trackbar_handler(int value, void *user_data){
std::map <String, void*> *user_data_map;
user_data_map = reinterpret_cast<std::map<String, void *> *>(user_data); //WORKED!! ;)

MainController *controller; //the same class type I put using "this" above
controller = reinterpret_cast<MainController *>( user_data_map["Object"]); //ERROR here

int *var = reinterpret_cast<int*> (user_data_map["h"]); //ERROR also here

Answer 1

>> should be > > and you do not want to dereference void pointer, instead cast void pointer to desired pointer type and then dereference

@casa has already provided you with answer to second problem

Answer 2

When you're casting from a void *, your result will be a pointer too. So the map declaration should be:

std::map <String, void*> *user_data_n;

Second, you should use reinterpret_cast for such (potentially dangerous) casts:

user_data_n = reinterpret_cast<std::map<String, void *> *>(user_data);

Update:

As others suggested, you could simply use a static_cast as well.

Why do I get that kind of message when casting it here and not when putting that object when setting the callback?

Any pointer can be implicitly converted to void *, but when converting it back to a pointer of some specific type, you need an explicit cast.

why I still get error when trying to cast objects contained in my map object?

As already mentioned in the comments, you need to dereference the pointer before using the map object. You might want to define a reference instead to make things easier:

std::map <String, void*> &user_data_map =
    *(static_cast<std::map<String, void *> *>(user_data));

Answer 3

An noted, the >> in that line to close your template should be > > (with a space).

Also, if user_data is a void pointer, you cannot dereference it. You could cast the pointer to another pointer type with reinterpret_cast:

std::map <String, void*> *user_data_n_ptr; //note this is a pointer to a map.
user_data_n_ptr = reinterpret_cast<std::map<String, void *> *>(user_data);

This will cast the void pointer to a std::map .

You should be careful with this. void pointers shouldn't typically be thrown around in c++. There may be a better way to do what you want and avoid void * all together.

Answer 4

I suppose this is for serving a C callback? It might be better to have a specialized struct which keeps all those values using the exact types. That way you'd be down to one cast for the whole thing. Something like this:

struct callback_user_data {
  my_class* that;
  int number;
  callback_user_data(my_class* p, int i) : that(p), number(i) {}
};

// the callback
void my_callback(void* user_data)
{
  callback_user_data* cbud = static_cast<callback_user_data*>(user_data);
  somehow_use(cbud->that, cbud->number);
}

//call the function, passing our user data
callback_user_data cbud(this, 42);
some_function_taking_our_callback(&my_callback, &cbud);

Note that usually I have this seen (and used) this so that not a special type is passed, but only this, which has all the necessary data anyway:

// the callback
void my_callback(void* user_data)
{
  my_class* that = static_cast<my_class*>(user_data);
  that->f();
  std::cout << that->number << '\n';
}

//call the function, passing our user data
some_function_taking_our_callback(&my_callback, this);