局部变量作为非类型模板参数

Question

我想做类似以下的事情：

Example(&Class::MemberFunction, this));

//...

template<class T_CLASS>
inline static void Example(void (T_CLASS::*MemberFunctionPointer)(), T_CLASS* InstancePointer)
{
  SomeClass<T_CLASS>::Bind<MemberFunctionPointer>(InstancePointer);
}

但我收到错误： *模板参数 'T_MEMBER_FUNCTION' : 'MemberFunctionPointer' : 局部变量不能用作非类型参数*

此问题有任何解决方案吗？我想提供一种更简单的方法来调用“Bind”，

谢谢，Mirco

//edit：

我希望 MemberFunctionPointer 成为一个非类型模板参数，因为在“Bind”中我再次需要它作为模板参数。 正如您在答案中所写，在我的例子中，MemberFunctionPointer 是一个变量，其值在编译时未知。但 MemberFunctionPointer 总是指向同一个函数。有没有一种方法可以使其恒定，以便编译器在编译时知道它？

Answer 1

模板参数可以有两种：类型和编译时常量表达式。函数参数的内容不是编译时可确定的值。因此，编译器无法基于它实例化模板。

请记住：模板是一种类型。并且类型必须在编译时可确定。

您可能应该将成员指针作为参数传递给 Bind 函数。

Answer 2

我不太确定你想达到什么目的？

如果 MemberFunctionPointer 是一个变量，其值在编译时未知，并且例如可能取决于某些用户行为 - 那么它不能用作模板参数。

另一方面，如果可以在编译时实际推导 MemberFunctionPointer，则应将其作为模板参数而不是函数参数传递。考虑以下示例：（

在第一种情况下使用 Bind 和 call；在第二种情况下，使用 StaticBind 和 callStatic)

#include <stdio.h>

class X {
  public:
    int x;
    void foo() {printf("foo\n");}
    void bar() {printf("bar\n");}
};

template <typename T>
class SomeClass {
  public:
    static void Bind(void (T::*MemberFunctionPointer)(), T *obj) {
      (obj->*MemberFunctionPointer)();
    }
    template <void (T::*MemberFunctionPointer)()>
    static void StaticBind(T *obj) {
      (obj->*MemberFunctionPointer)();
    }
};

template <class C>
static inline void call(void (C::*MemberFunctionPointer)(), C *obj) {
  SomeClass<C>::Bind(MemberFunctionPointer,obj);
}

template <class C, void (C::*MemberFunctionPointer)()>
static inline void callStatic(C *obj) {
  SomeClass<C>::template StaticBind<MemberFunctionPointer>(obj);
}

int main() {
  X obj;
  call<X>(&X::foo,&obj);
  callStatic<X,&X::bar>(&obj);
  return 0;
}

Answer 3

模板参数必须在编译时已知。作为函数参数的指针变量的内容取决于该函数的调用方式。这在编译时是未知的！

如果您在编译时已经知道该指针，则可以将函数指针运行时参数转换为模板参数：

template<class T_CLASS, void(T_CLASS::*MemFunPtr)()>
void Example(T_CLASS* InstancePointer) {...}

这里，MemFunPtr 是一个在编译时已知的模板参数，因此可以重新用作另一个函数的模板参数或类模板...

Answer 4

MemberFunctionPointer 是一个变量，而不是类型（或编译时常量），因此无法使用，您需要的是该函数的真实签名，类似这样的东西可能是更好..

template<typename T_FUNC_PTR, class T_CLASS>
inline static void Example(T_FUNC_PTR fPtr, T_CLASS* InstancePointer)
{
  SomeClass<T_CLASS>::Bind<T_FUNC_PTR>(fPtr, InstancePointer);
}

即让编译器推断出函数指针的类型（注意：您也必须将指针传播到函数），以调用

Example(&foo::bar, foo_inst);

这是未经测试的并且超出了我的想象，因此语法可能会稍微偏离...

编辑：这里是一个更简单的例子来演示这个概念：

#include <iostream>
struct foo
{
  void bar() { std::cout << "foo::bar()" << std::endl; }
};

template<typename T_FUNC_PTR, typename T_CLASS>
void exec(T_FUNC_PTR ptr, T_CLASS& inst)
{
  (inst.*ptr)();
}

int main(void)
{
  foo inst;
  exec(&foo::bar, inst);
}