Question

我似乎无法以下列方式使用多层模板，

template <typename T>
template <T value>
void printValueAsInteger()
{
    printf("value as integer is %i\n", (int) value);
}

以便它可以被称为：

printValueAsInteger<123>();

导致以下错误消息：too many template-parameter-lists。

如果我将template <typename T, T value>与printValueAsInteger<int, 123>()一起使用，则可行，但这需要我明确指定类型。我怎样才能使printValueAsInteger<123>()打印value as integer is 123？

修改

我将更具体地说明我需要的东西。我的目标是将成员函数作为函数指针传递，我想使用模板包装它：

template <typename T>
template <T* instance, void (T::*method)()>
void wrappedMethod()
{
    (instance->*method)();
}
void callFunction(void (*function)())
{
    (*function)();
}

然后像这样传递：

Base *instance = new Derived;
callFunction(&wrappedFunction<instance, Base::method>);

修改

呃，我刚才意识到我可能不应该（也不能）使用运行时定义的变量作为模板参数。我现在正在尝试使用其他模板参数实例化的类并创建使用该类的模板函数来解决它。或类似的东西。不，不行。

请注意，我无法更改callFunction的签名，因为它是第三方API的一部分。

最后！

我将以下内容放在标题中，

class Callable
{
public:
    virtual ~Callable() { }
    virtual void call() { }
};

typedef void (*functionPtr)();
extern unsigned nextMethodId;
extern functionPtr wrappedMethods[];
extern Callable *boundMethods[];

template <unsigned I>
class MethodWrapper
{
public:
    static void function();
};

template <typename T>
class Method : public Callable
{
public:
    Method(T* instance, void (T::*method)());
    virtual void call();
private:
    T* instance;
    void (T::*method)();
};

template <typename T>
Method<T>::Method(T* instance, void (T::*method)())
    : instance(instance), method(method) {
}

template <typename T>
void Method<T>::call()
{
    if (instance && method)
        (instance->*method)();
}

template <typename T>
static functionPtr bindMethod(T* instance, void (T::*method)())
{
    boundMethods[nextMethodId] = new Method<T>(instance, method);
    return (void (*)()) wrappedMethods[nextMethodId++];
}

并在源文件中：

#include "<insert header name here>.h"

unsigned nextMethodId = 0;
functionPtr wrappedMethods[] = {
    &MethodWrapper<0>::function,
    &MethodWrapper<1>::function,
    &MethodWrapper<2>::function
};
Callable *boundMethods[sizeof(wrappedMethods) / sizeof(functionPtr)];

template <unsigned I>
void MethodWrapper<I>::function()
{
    boundMethods[I]->call();
}

我可以这样使用它：

Base *instance = new Derived;
void (*function)() = bindMethod(instance, &Base::method);
callFunction(function);

它成功调用派生实例的方法版本。遗憾的是，允许绑定的方法数量是固定的（在本例中为3），但它很容易扩展。

Answer 1

一个简单的转换是让 runtime 值成为一个仿函数的构造函数的参数，该仿函数包含实例指针和指向成员函数的指针。使用地点的语法将改为：

Base *instance = new Derived;
callFunction(&wrappedFunction<instance, Base::method>);

要：

callFunction( WrappedFunction<Base,&Base::method>( instance ) );

WrappedFunction类型的实现实际上很简单，所以我把它留作练习。请注意，此方法的主要变化是callFunction的参数变为仿函数，而不是函数指针。

在C ++ 11（或使用boost）中，最简单的方法是不编码任何内容，只使用可用资源。将callFunction的签名更改为：

void callFunction( function<void ()> f );

使用bind拨打电话：

callFunction( bind( &Base::method, instance ) );

Answer 2

对于第一个示例，您可以指定int作为模板参数的类型：

template <int I>
void printValueAsInteger()
{
    printf("value as integer is %i\n", I);
}

对于编辑，您不能使用已经提到的运行时定义的变量，因为模板在编译时使用。使用std::bind和std::function可以简化：

void callFunction(std::function<void()> f)
{
    f();
}

Base *instance = new Derived;
callFunction(std::bind(&Base::method, instance));

评论后

我能想到的唯一方法是让你的成员函数static：

callFunction(&Base::method); // Okay if the method is declared static

或者使用具有全局实例的全局包装函数：

Base *instance = new Derived; // Global
void wrapperFunction()
{
    instance->method();
}

callFunction(wrapperFunction);

使用template参数作为模板参数类型

2 个答案: