Anything I'm missing on this delegate implementation? Just as the question states and to be sure, am I missing anything on this? Something important/obvious that I overlooked? As is, I can save any functor, function pointer and member function pointer using this delegate class (copy ctor and assignment operator left out for brevity, as were the versions with parameters).

template&lt;class Type&gt;
void Deleter(void* object){
    Type* obj_ptr = static_cast&lt;Type*&gt;(object);
    delete obj_ptr;
}

template&lt;class Functor&gt;
struct DelegateHelper{
    typedef typename Functor::result_type result_type;

    DelegateHelper(Functor func)
        : func_(func)
    {}

    result_type operator()(){
        return func_();
    }

    Functor func_;
};

template&lt;class Obj, class R&gt;
struct DelegateHelper&lt;R (Obj::*)()&gt;{
    typedef R (Obj::*FuncPtr)();

    DelegateHelper(Obj* obj_ptr, FuncPtr func)
        : object_(obj_ptr)
        , func_(func)
    {}

    R operator()(){
        return (object_-&gt;*func_)();
    }

    Obj* object_;
    FuncPtr func_;
};

template&lt;class R&gt;
struct DelegateHelper&lt;R (*)()&gt;{
    typedef R (*FuncPtr)();

    DelegateHelper(FuncPtr func)
        : func_(func)
    {}

    R operator()(){
        return (*func_)();
    }

    FuncPtr func_;
};

template&lt;class Sig&gt;
struct Delegate;

template&lt;class R&gt;
struct Delegate&lt;R ()&gt;{
    typedef R (*SinkPtr)(void*);

    Delegate()
        : object_(0)
        , func_(0)
        , deleter_(0)
    {}

    template&lt;class F&gt;
    Delegate(F func)
        : object_(new DelegateHelper&lt;F&gt;(func))
        , func_(&amp;Sink&lt;DelegateHelper&lt;F&gt; &gt;)
        , deleter_(&amp;Deleter&lt;DelegateHelper&lt;F&gt; &gt;)
    {}

    template&lt;class C, class F&gt;
    Delegate(C* obj, F func)
        : object_(new DelegateHelper&lt;F&gt;(obj, func))
        , func_(&amp;Sink&lt;DelegateHelper&lt;F&gt; &gt;)
        , deleter_(&amp;Deleter&lt;DelegateHelper&lt;F&gt; &gt;)
    {}

    ~Delegate(){
        if(deleter_)
            (*deleter_)(object_);
    }

    R operator()(){
        return (*func_)(object_);
    }

    template&lt;class Type&gt;
    static R Sink(void* obj_ptr){
        Type* object = (Type*)obj_ptr;
        return (*object)();
    }

    typedef void (*DeleteFunc)(void*);

    void* object_;
    SinkPtr func_;
    DeleteFunc deleter_;
};


For the delegate in effect, see here on Ideone.
You are missing const and volatile qualified method pointer versions.

Example:

template&lt;class Obj, class R&gt;
struct DelegateHelper&lt;R (Obj::*)() const&gt;{
    typedef R (Obj::*FuncPtr)() const;

    DelegateHelper(const Obj* obj_ptr, FuncPtr func)
        : object_(obj_ptr)
        , func_(func)
    {}

    R operator()(){
        return (object_-&gt;*func_)();
    }

    const Obj* object_;
    FuncPtr func_;
};


Also, you may (probably) need specializations or internal delegates for handling of functions with void return values. Someone else may be able to fill in the details, but it seems some compilers are OK with

return function_returning_void();


And others are not.

Another thing that makes the boost version and some others larger is being able to accept &amp; or * arguments for the object value when calling methods.