[This question has a Boost.Function relation later on. Sorry if too off topic.] I have a class that works on some data structures. This class' API uses void* to be general and avoid code duplication that using a template here would incur. Basically: class A // simplification { // Assume A to be a "fat" class there are more methods // working on void* // and lots of code put away into a .cpp file. We don't // want that duplicated by many template instantiations. public: // Most of the work is generic and independent from the // data types worked on. void do_something(void*); protected: // some work has to be done be the subclass virtual bool help_me(const void*) =0; }; I do not like using void* all that much. Thus I would like to create a type-safe (generic) thin wrapper class. Using inline functions,the idea is that the run time penalty (at least for do_something) is low and casts from/and to void are all 'hidden' here. template<typename T> class B : public A { public: void do_something(T* t) { A::do_something(t); } protected: // Force user to provide a correctly typed callback. virtual bool help_me(const T*) =0; private: // call the user's safe callback bool help_me(const void* t) { return help_me(static_cast<const T*>(t)); } }; and finally class C : public B<MyStruct> { bool help_me(const MyStruct* ms) { ... } }; Is this a good way to do that? More specific questions: i) I assume the penalty for my callback "help_me" is one more indirection. Can't see that optimized away. ii) Assuming A's interface gets passed a real callback function (a Boost.Function) instead: class A { public: typedef boost::function<bool(const void*)> helper_func; void do_something(void*, helper_func); }; is it somehow possible to get a typesafe templated B such that template<typename T> class B : public A { public: typedef boost::function<bool(const T*)> helper_func; void do_something(T* t, helper_func hf) { // this makes my compiler unhappy (when instanced). // I do understand that... can it be worked around somehow? A::do_something(t, hf); } }; I would like to be able to pass a function working on T* rather than void*. While writing this posting have found the following to compile: template<typename T> struct ToVoidWrapper { typedef boost::function<bool(const T*)> helper_func; helper_func hf_; ToVoidWrapper(const helper_func &hf) : hf_(hf) {} bool func(const void *t) const { return hf_(static_cast<const T*>(t)); } }; with do_something in B: void do_something(T* t, helper_func hf) { ToVoidWrapper<T> vw(hf); A2::do_something(t, boost::bind(&ToVoidWrapper<T>::func, &vw, _1)); } I am not really looking forward to writing such "forwarding to void*" functions. Are there alternatives? Maybe something in Boost that I have overlooked? Or a standard C++ idiom I am not aware of? I have attached compilable code that sums up the above code snippets so far. Thank you for looking into this and best regards Christoph