“变量”不是类型'指向成员函数'的有效模板参数

Question

我对C++和模板都很陌生，我尝试修改一个可用于使委员从成员功能。

我改变了这种代码（编译）：

Delegate<void, int, int>* cheaty(void (Renderer::*method)(int, int), Renderer* obj) 
    { 
     auto maker = DelegateMaker<Renderer, void, int, int>(); 
     return maker.BindPointer<&Renderer::MoveCamera>(obj); 
    } 

要这样：

Delegate<void, int, int>* cheaty(void (Renderer::*method)(int, int), Renderer* obj) 
    { 
     auto maker = DelegateMaker<Renderer, void, int, int>(); 
     return maker.BindPointer<method>(obj); 
    } 

这并不编译并提供了以下错误：error: 'method' is not a valid template argument for type 'void (Engine::Renderer::*)(int, int)'。由于C++模板的局限性，我试图实现的目标根本不可能实现吗？还是我错过了一些非常明显的东西？

编辑： 理想情况下，我想有是这样的功能：

template<typename T, typename return_type, typename... params> 
    Delegate<return_type, params...>* make_delegate_pointer(return_type (T::*name)(params...), T* obj) 
    { 
     DelegateMaker<T, return_type, params...> maker = DelegateMaker<T, return_type, params...>(); 
     return maker.BindPointer<name>(obj); 
    } 

然后调用它像这样auto delegate = Delegates::make_delegate_pointer(&Class::Method, &classInstance);只是，我一直运行到的问题是，似乎有事实在调用BindPointer这样的maker.BindPointer<&Class::Method>(classInstance);并将其称为maker.BindPointer<return_type (Class::*)(arguments...)>(classInstance);之间有些区别。

但是，return_type (T::*)(params...) memberFuncPointer = &Class::Method编译得很好。这意味着在逻辑上，maker.BindPointer<return_type (T::*)(params...)>(classInstance)也应该编译（或者对其进行一些修改，这就是为什么我试图用method作为void (Renderer::*method)(int, int)的原始问题）。但事实并非如此。

Answer 1

在编译时必须知道模板参数值，但是method值直到运行时才会知道，因为cheaty()不知道将哪个方法Renderer传递给它。因此编译器错误。您将不得不更改BindPointer以不再使用模板。另外，DelegateMaker已经知道了方法签名，因此您不需要将该信息作为BindPointer()中的模板参数进行复制，让它继承DelegateMaker中的值。

例如（未经测试，可能需要一些调整，但你应该得到的总体思路）：

template <typename ReturnType, typename... ParamTypes> 
class Delegate 
{ 
public: 
    virtual ReturnType Invoke(ParamTypes... params) = 0; 
}; 

template <typename ClassType, typename ReturnType, typename... ParamTypes> 
class DelegateMaker 
{ 
public: 
    typedef ReturnType (ClassType::*MethodType)(ParamTypes... params); 

private: 
    class DelegateImpl : public Delegate<ReturnType, ParamTypes...> 
    { 
    private: 
     ClassType* _obj; 
     MethodType _method; 

    public: 
     DelegateImpl(ClassType *obj, MethodType method) 
      : _obj(obj), _method(method) 
     { 
     } 

     virtual ReturnType Invoke(ParamTypes... params) 
     { 
      return (_obj.*_method)(params); 
     } 
    }; 

public: 
    Delegate<ReturnType, ParamTypes...>* BindPointer(MethodType method, ClassType *obj) 
    { 
     return new DelegateImpl(obj, method); 
    } 
}; 

template <typename ClassType, typename ReturnType, typename... ParamTypes> 
Delegate<ReturnType, ParamTypes...>* make_delegate_pointer(
    DelegateMaker<ClassType, ReturnType, ParamTypes...>::MethodType method, 
    ClassType* obj) 
{ 
    DelegateMaker<ClassType, ReturnType, ParamTypes...> maker; 
    return maker.BindPointer(method, obj); 
} 

auto delegate = Delegates::make_delegate_pointer(&Class::Method, &classInstance);