Question

获取重载成员函数（真实成员和具有替代调用约定的静态成员）地址的常用方法是什么？
如果使用其他调用约定，以下示例将失败：

xx

请参见live示例。

背景：
我不知道实现是使用成员函数还是静态成员函数，因此，我需要一种通用的方式来处理这两个函数。如上所示，显而易见的方法并不成功。

Answer 1

如果您需要能够以相同的方式处理表达式&A::x，而不管x是A的静态成员还是非静态成员（并且它可能会重载）），那么您需要将其传递给其他可以接受R(C::*)(Ts...)或R(C::*)(Ts...)const或R(*)(Ts...)的重载函数，并进行相应的调度。像这样：

template <typename... Ts>
struct UniformResolver {
    template <typename C, typename R>
    constexpr auto operator()(R (C::*func)(Ts...)) const { return resolveMember(func); }
    template <typename C, typename R>
    constexpr auto operator()(R (C::*func)(Ts...) const) const { return resolveMember(func); }
    template <typename R>
    constexpr auto operator()(R (*func)(Ts...)) const { return resolveStatic(func); }
private:
    template <typename F>
    constexpr auto resolveMember(F func) const {
        return [func](auto&&... args) {
            return std::invoke(func, std::forward<decltype(args)>(args)...);
        };
    }
    template <typename F>
    constexpr auto resolveStatic(F func) const {
        return [func](auto&&, auto&&... args) {
            return std::invoke(func, std::forward<decltype(args)>(args)...);
        };
    }
};
template <typename... Ts>
constexpr UniformResolver<Ts...> uresolve {};

这为您提供了一个可调用对象模板uresolve，该模板可适应您的函数指针，返回可以以统一方式调用并委托给您的函数指针的可调用对象。这是您将如何使用它：

struct A {
    int mem(int a) const { return a * 2; }
    int mem(int a, int b) const { return a + b; }
    static int stat(int a) { return a * 2; }
    static int stat(int a, int b) { return a + b; }
};

int main() {
    A a;
    auto mem1 = uresolve<int>(&A::mem);
    auto mem2 = uresolve<int, int>(&A::mem);
    auto stat1 = uresolve<int>(&A::stat);
    auto stat2 = uresolve<int, int>(&A::stat);

    std::cout << mem1(a, 1) << '\n';
    std::cout << mem2(a, 1, 2) << '\n';
    std::cout << stat1(a, 1) << '\n';
    std::cout << stat2(a, 1, 2) << '\n';
}

Live demo

Answer 2

要允许将具有相似声明的函数存储在单个变量std::function中。

具有单个参数的函数：

std::function< int(int) > func_1_param;

func_1_param = static_cast< int (*)(int) >(&A::stat);
cout << "int(int)->" << func_1_param(1) << endl;

using  std::placeholders::_1;

func_1_param = std::bind(static_cast< int (A::*)(int) >(&A::mem), &a, _1);
cout << "int(int)->" << func_1_param(1) << endl;

具有2个参数的功能；

std::function< int(int, int) > func_2_param;

func_2_param = static_cast< int (*)(int, int) >(&A::stat);
cout << "int(int, int)->" << func_2_param(1, 2) << endl;

using  std::placeholders::_1;
using  std::placeholders::_2;

func_2_param = std::bind(static_cast< int (A::*)(int, int) >(&A::mem), &a, _1, _2);
cout << "int(int, int)->" << func_2_param(1, 2) << endl;

可以使用lambda代替使用std::bind。

Answer 3

据我所知，没有办法将静态成员函数转换为成员函数指针以通用方式解决重载，也没有任何其他直接方法。
从Jarod42中获得提示，可以通过某些代理类，函数或在这种情况下为lambda（只要不捕获）进行间接寻址，从而提供以下解决方案：

#include <iostream>


using namespace std;


struct A {
    int mem(int a) {
        return a * 2;
    };
    int mem(int a, int b) {
        return a + b;
    }
    static int stat(int a) {
        return a * 2;
    }
    static int stat(int a, int b) {
        return a + b;
    }
};


static A a;


int main() {
    typedef int(*type1)(int);
    typedef int(*type2)(int, int);

    cout << "a.mem(1) -> " << a.mem(1) << endl;
    cout << "a.mem(1, 2) -> " << a.mem(1, 2) << endl;
    cout << "A::stat(1) -> " << A::stat(1) << endl;
    cout << "A::stat(1, 2) -> " << A::stat(1, 2) << endl;
    cout << "a.stat(1) -> " << a.stat(1) << endl;
    cout << "a.stat(1, 2) -> " << a.stat(1, 2) << endl;

    cout << "----------------------------------" << endl;

    type1 aMem1 = [] (int a0) -> int { return a.mem(a0); };
    cout << "aMem1(1) -> " << aMem1(1) << endl;
    type2 aMem2 = [] (int a0, int a1) -> int { return a.mem(a0, a1); };
    cout << "aMem2(1, 2) -> " << aMem2(1, 2) << endl;
    type1 stat1 = [] (int a0) -> int { return A::stat(a0); };
    cout << "stat1(1) -> " << stat1(1) << endl;
    type2 stat2 = [] (int a0, int a1) -> int { return A::stat(a0, a1); };
    cout << "stat2(1, 2) -> " << stat2(1, 2) << endl;
    type1 aStat1 = [] (int a0) -> int { return a.stat(a0); };
    cout << "aStat1(1) -> " << aStat1(1) << endl;
    type2 aStat2 = [] (int a0, int a1) -> int { return a.stat(a0, a1); };
    cout << "aStat2(1, 2) -> " << aStat2(1, 2) << endl;

    return 0;
}

请参见live示例。

这通过使用与实施用户相同的调用约定来利用原始问题。这意味着，如果用户能够以这种方式调用成员函数（无论是静态的还是非静态的），那也是因为我们使用的是相同的调用约定。可以通过使用代理类来继续使用成员函数指针。对我来说，lambda方法效果更好。

C ++获取重载成员函数指针的常用方法

3 个答案: