Hiding / avoiding / postponing type?

So I have a simple class that I want to take a functor:

Code:

template<typename T>
class CMyMFCEditBrowseCtrl: public CMFCEditBrowseCtrl
{
public:
	CMyMFCEditBrowseCtrl(T OnAfterUpdateFunc): m_OnAfterUpdateFunc(OnAfterUpdateFunc) {}
	virtual void OnAfterUpdate() { m_OnAfterUpdateFunc(); }

protected:
	T m_OnAfterUpdateFunc;
};

Now, since this is a derived class that merely overrides a virtual function, it must be in my header:

Code:

class CVideoEncoderforN8Dlg : public CDialogEx
{
	...
	CMyMFCEditBrowseCtrl<?> m_VideoCtrl;
	...
};

But there is the problem. I need to put in a functor, so I don't know the type. And since I cannot define the functor inside the header, I cannot deduce the type.
So I need to hide or post-pone the type in some way. So this is what I wanted to ask. What is good solution for this kind of situation? What are some good techniques?

Not sure where exactly is the problem, but

Code:

class CMyMFCEditBrowseCtrl: public CMFCEditBrowseCtrl
{
        typedef std::function<void()> AfterUpdateFun;
public:
	CMyMFCEditBrowseCtrl(AfterUpdateFun OnAfterUpdateFunc): m_OnAfterUpdateFunc(OnAfterUpdateFunc) {}
	virtual void OnAfterUpdate() { m_OnAfterUpdateFunc(); }

protected:
	AfterUpdateFun m_OnAfterUpdateFunc;
};

That is a problem because it means I cannot do

Code:

CMyMFCEditBrowseCtrl b(&A::test);

Hence the templated type T, which gives me the opportunity to pass in a function pointer, functor or member function (though via a functor).

A std::function accepts all of those too?

Code:

CMyMFCEditBrowseCtrl b(std::function<void()>(std::bind(&A::test, some_a)));

Ah, so it does. Long time last since I used boost::bind.
It seems like an acceptable solution, for now, at least.

Although, still, this seems like a compromise. What if I have to do this with a generic class taking one or more functors?
I would either have to rewrite them or use some other solution.

Unfortunately the only other way I know is to make class CVideoEncoderforN8Dlg a template too. But I think you knew that because you said:

... And since I cannot define the functor inside the header, I cannot deduce the type.

About that I do not understand. Functors are types, so you can separate the implementation from design like normal. If the functors themselves are templates, then you can define them in a separate header and include them later. So there would have to be some other reason why you can't deduce the type. I do not think the inheritance precludes this.