我怎样摆脱这个reinterpret_cast，或者这个用法好吗？

Question

I have a template member function with this signature:

template<typename T> void sync(void (*work)(T*), T context);

It can be called with a pointer to a function that accepts an argument of type T* . context is passed to that function. The implementation is this:

template<typename T> void queue::sync(void (*work)(T*), T context) {
  dispatch_sync_f(_c_queue, static_cast<void*>(&context),
                  reinterpret_cast<dispatch_function_t>(work));
}

It uses reinterpret_cast<> and it works. The problem is that the standard doesn't define it very well and it is very dangerous. How can I get rid of this? I tried static_cast but that gave me a compiler error:

static_cast from void (*)(std::__1::basic_string<char> *) to dispatch_function_t (aka void (*)(void *) ) is not allowed.

dispatch_function_t is a C type and is the same as void (*)(void*) .

---

I'm not sure I was clear enough. What dispatch_sync_f does is it calls a given callback function and passes the given context parameter to that callback function. (It does that on another thread, although that is out of the scope of this question.)

Answer 1

The reason this is not supported by static_cast is because it is potentially unsafe. While a std::string* will convert implicitely to a void* , the two are not the same thing. The correct solution is to provide a simple wrapper class to your function, which takes a void* , and static_cast s it back to the desired type, and pass the address of this wrapper function to your function. (In practice, on modern machines, you'll get away with the reinterpret_cast , since all pointers to data have the same size and format. Whether you want to cut corners like this is up to you—but there are cases where it's justified. I'm just not convinced that this is one of them, given the simple work-around.)

EDIT: One additional point: you say that dispatch_function_t is a C type. If this is the case, the actual type if probably extern "C" void (*)(void*) , and you can only initialize it with functions that have "C" linkage. (Again, you're likely to get away with it, but I've used compilers where the calling conventions were different for "C" and "C++" .)

Answer 2

I guess, you are not only casting work to dispatch_function_t , but calling it through dispatch_function_t pointer, aren't you? Such cast itself is valid according to standard, but all you can do with a casted pointer is cast it back to original type. Still your approach should work with most compilers and platforms. If you'd like to implement it so it's more standard conforming you can make a wrapper for your context and work function like this:

template <typename T>
struct meta_context_t
{
  T *context;
  void (*work)(T*);
};

template <typename T>
void thunk(void *context)
{
  meta_context_t<T> *meta_context = static_cast<meta_context_t<T> *>(context);
  meta_context->work(meta_context->context);
}

template<typename T> void queue::sync(void (*work)(T*), T context) {
  meta_context_t<T> meta_context =
  {
    &context,
    work
  };

  dispatch_sync_f(_c_queue, static_cast<void*>(&meta_context),
                thunk<T>);
}

Answer 3

I can't believe this works or you have a rather narrow definition of "this works" (eg you found one particular setup where it seems to do what you think it should do). I'm not clear what dispatch_sync_f() does but I think it is suspicious that it gets a pointer to the local variable context as parameter. Assuming this variable outlives the use of this pointer, there is still a subtle problem which won't get you on most platforms but does get you on some:

C and C++ calling conventions can be different. That is, you cannot cast a pointer to a C++ function to a pointer to a C function and hope for this to be callable. The fix to this problem - and your original question - is, of course, an extra level of indirection: don't dispatch to the function you get as argument but rather dispatch to a C function (ie a C++ function declared as extern "C" ) which takes its own context holding both the original context and the original function and calls the original function. The only [explicit] cast needed is the static_cast<>() restoring a pointer to your internal context from the void* .

Since you seem to implement a template you might need to use another indirection to get rid of this type: I don't thing function templates can be declared extern "C" . So you would need to restore the original type somehow eg using a base class and a virtual function or something like std::function<void()> holding a readily callable function object doing this conversion (a pointer to this object would be your context).

Answer 4

I believe the cast to/from these two function pointer types is fine:

void(*)(void*)
void(*)(T*)

The problem is that you can't actually use the pointer that you have so cast. It's legal only to cast back to the original type (and those casts are reinterpret_cast , because these are unrelated types). From your code, I can't see how your actual callback function is defined. Why can't you accept a dispatch_function_t as your parameter for queue::sync , rather than casting it?

Answer 5

reinterpret_cast is guaranteed to work when converting from a type T * to void * and back. It is, however, not acceptable to cast from or to a pointer to a base or derived class of T.

The type of work needs to be dispatch_function_t in this case, and the first order of business in that function needs to be the cast from void * to T * . Implicitly casting the argument by using a different argument type and casting the function type is not allowed.

Rationale: the standard allows different pointer representations for different types, as long as all pointer types can be converted to void * and back, so void * is the "most precise" pointer type. A conforming implementation is allowed to clear the bottom-order bits of an uint32_t * if sizeof(uint32_t) > sizeof(char) (ie sizeof(uint32_t) > 1 ) or even shift the pointer value if the machine instructions can utilize these pointers more effectively; on a machine with tagged or shifted pointer values the reinterpret_cast is not necessarily a no-op and needs to be written explicitly.