c++ - 是否可以使用方便的语法调用成员函数指针来专门化一个函数？

Question

看看这个非编译片段:

struct Object {
    template <RETURN (OBJECT::*MEMFN)(PARAMETERS...), typename RETURN, typename OBJECT, typename ...PARAMETERS>
    void call() {
    }
};

struct Foo {
    void fn();
};

int main() {
    Object o;
    o.call<&Foo::fn>();
}

基本上，我想要实现的是有一个函数(Object::call)，它专门用于任何类型的成员函数指针，具有方便的调用语法。

我找到的最接近的解决方案是这个，它非常难看:

struct Object {
};

template <typename MEMFNTYPE, MEMFNTYPE MEMFN>
struct Caller;

template <typename RETURN, typename OBJECT, typename ...PARAMETERS, RETURN (OBJECT::*MEMFN)(PARAMETERS...)>
struct Caller<RETURN (OBJECT::*)(PARAMETERS...), MEMFN> {
    Object *object;

    Caller(Object &o) : object(&o) { }

    void call() {
        // I have the necessary information here: the member function pointer as template parameter, and a pointer to Object
    }
};

struct Foo {
    void fn();
};

int main() {
    Object o;

    Caller<decltype(&Foo::fn), &Foo::fn>(o).call();
}

这个问题有更好的解决方案吗？

(我尝试这样做的原因是我想为其他成员函数创建包装函数(call))

---

Kerrek SB 建议使用 auto，我已经试过了:

struct Object {
    template <auto MEMFN>
    void call();

    template <auto MEMFN, typename RETURN, typename OBJECT, typename ...PARAMETERS>
    void call<RETURN (OBJECT::*MEMFN)(PARAMETERS...)>() {
    }
};

struct Foo {
    void fn();
};

int main() {
    Object o;
    o.call<&Foo::fn>();
}

但是，这不会编译(我是否需要将 MEMFN 添加到模板参数列表中(而不是 auto MEMFN？):

t2.cpp:6:7: error: parse error in template argument list
  void call<RETURN (OBJECT::*MEMFN)(PARAMETERS...)>() {
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
t2.cpp:6:52: error: non-class, non-variable partial specialization ‘call<<expression error> >’ is not allowed
  void call<RETURN (OBJECT::*MEMFN)(PARAMETERS...)>() {

Answer 1

正如评论中所建议的那样，如果您接受 C++17 解决方案，那么 auto是你的 friend 。 <type_traits>也是如此和 if constexpr :

#include <type_traits>
#include <iostream>

struct Object {
    template <auto MEMFN>
    void call() {
        if constexpr (std::is_member_function_pointer_v<decltype(MEMFN)>)
            std::cout << "Is member\n";
    }
};

struct Foo {
    void fn();
};

int main() {
    Object o;
    o.call<&Foo::fn>();
}

如果类型特征表明确实如此，函数体只会发出将参数视为成员函数指针的代码。无需特化。