локальная переменная как аргумент шаблона нетипа

Существует два вида параметров шаблона: типы и постоянные выражения времени компиляции. Содержимое параметра функции не является значением, определяемым во время компиляции. И поэтому компилятор не может создать экземпляр шаблона на его основе.

Помните: шаблон — это тип. И типы должны быть определяемыми во время компиляции.

Вероятно, вам следует передать указатель члена в качестве аргумента функции Bind.

Я не совсем уверен, чего вы пытаетесь достичь?

Если 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;
}

Параметры шаблона должны быть известны во время компиляции. Содержимое переменной-указателя, которая является параметром функции, зависит от того, как вызывается эта функция. Это неизвестно во время компиляции!

Если вы уже знаете этот указатель во время компиляции, вы можете превратить параметр времени выполнения указателя функции в параметр шаблона:

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

Здесь MemFunPtr — это параметр шаблона, который известен во время компиляции и, таким образом, может повторно использоваться в качестве параметра шаблона для другой функции или шаблона класса...

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);
}