4

我制作了一个模板函数，它以成员函数作为参数。

但是，由于必须先声明该类，然后才能将其用作成员函数参数的一部分，因此我必须将其设为单独的参数：

template<typename C, void (C::*Method)(void)>
function<void(C*)> methodWrap()
{
}

这意味着当显式实例化模板时（我希望在编译时生成这些包装器，而不是将成员指针作为参数传递）我必须在使用它时输入两次：

function<void(C*)> someFunc = wrapMethod<SomeClass, &SomeClass::someMethod>();

为什么我不能只写类似 tis 的东西：

template<void (C::*Method)(void)>
function<void(C*)> methodWrap()
{
}

并让它捕获 C 的类型及其成员函数指针而不必键入 SomeClass 两次？

或者为什么我不能将它包装在一个将 C 声明为“自由变量”的外部模板中，然后有一个内部模板参数来执行推论

template<typename C>
template<void (C::*Method)(void)>
function<void(C*)> methodWrap()
{
}
4

2 回答 2

2

如果您可以为成员函数指针使用普通函数参数而不是使其成为模板参数，那么您可以这样做

#include <functional>

template<typename R, typename C, typename... Args>
struct MemberFunctionPointer
{
    typedef R Return;
    typedef C Class;
};

template<typename R, typename C>
constexpr auto inferMemberFunctionPointer(R (C::*method)())
{
    return MemberFunctionPointer<R,C>{};
}

template<typename T> 
constexpr auto methodWrap(T m)
{
    typedef typename decltype(inferMemberFunctionPointer(m))::Class Class;
    typedef typename decltype(inferMemberFunctionPointer(m))::Return Return;

        return std::function<Return (Class*)>();
}

struct B {};

struct A
{
    B f();   
};

void foo()
{
    auto const m = methodWrap( &A::f );
}

std::function不是constexpr类型，所以我们不能使用 methodWrap 来初始化constexpr变量。您可以通过创建自己的简单constexpr成员函数包装器来绕过它。我还添加了一个static_assert以获得更好的错误消息。

#include <functional>

template<typename R, typename C, typename... Args>
struct MemberFunctionPointer
{
    typedef R Return;
    typedef C Class;
};

template<typename R, typename C>
constexpr auto inferMemberFunctionPointer(R (C::*method)() const)
{
    return MemberFunctionPointer<R,C>{};
}

template<typename R, typename C>
struct MemberFunction
{
    constexpr explicit MemberFunction(R (C::*g)() const): f(g) {}

    constexpr R operator()(C const* obj) const
    {
        return (obj->*f)();
    }

    R (C::*f)() const;
};

template<typename T> 
constexpr auto methodWrap(T m)
{
    static_assert( std::is_member_function_pointer<T>::value, 
                   "Member function pointer expected!");

    typedef typename decltype(inferMemberFunctionPointer(m))::Class Class;
    typedef typename decltype(inferMemberFunctionPointer(m))::Return Return;

        return MemberFunction<Return, Class>{ MemberFunctionPointer<Return,Class>{} };
}

struct B {};

struct A
{
    constexpr B f() const;   
};

void foo()
{
    auto constexpr m = methodWrap( &A::f );
    auto constexpr a = A{};
    m( &a );

    auto b = A{};
    m( &b );
}
于 2015-12-17T08:53:08.750 回答
0

为什么我不能写这样的东西：

template<void (C::*Method)(void)>
function<void(C*)> methodWrap()

因为这里无法确定C's 的类型。因此需要typename C.

或者为什么我不能将它包装在一个将 C 声明为“自由变量”的外部模板中，然后有一个内部模板参数来执行推论

我不确定这将如何帮助您解决困境。您仍然需要一种在模板参数列表中指定对象类型的方法。

你可以做这样的事情：

 template<typename C>
 std::function<void(C&)> wrap(void(C::*mf)())
 {
   return std::function<void(C&)>(mf);
 }

用法：wrap(&Obj::memfun);

当然，要通过指针实际调用非静态成员函数，您将需要一个实例对象。

于 2015-12-17T06:03:01.390 回答