无法将初始化列表转换为std::map：类成员函数指针初始化问题求助

你遇到的编译错误核心原因是类的非静态成员函数指针和普通函数指针类型不兼容。非静态成员函数隐含一个this指针参数，所以它的指针类型是size_t (HashTableOpeningAddress<T>::*)(T, size_t)，而你定义的map值类型是普通函数指针size_t (*)(T, size_t)，两者无法直接转换，导致初始化失败。

下面提供三种可行的修正方案，根据你的实际需求选择：

方案一：将探测函数改为静态成员函数 #

如果探测函数不需要访问类的非静态成员，可以把它们声明为static，这样静态成员函数的指针类型和普通函数指针兼容：

template<typename T>
class HashTableOpeningAddress {
private:
    static size_t linearProbing(T key, size_t i) {
        // 实现逻辑
        return i;
    }
    static size_t quadraticProbing(T key, size_t i) {
        // 实现逻辑
        return i*i;
    }
    static size_t doubleHashing(T key, size_t i) {
        // 实现逻辑
        return i * hash2(key);
    }

    std::map<std::string, size_t (*)(T, size_t)> probeFunctionMap = {
        {"linearProbing", &HashTableOpeningAddress<T>::linearProbing},
        {"quadraticProbing", &HashTableOpeningAddress<T>::quadraticProbing},
        {"doubleHashing", &HashTableOpeningAddress<T>::doubleHashing}
    };
};

方案二：修改map类型为成员函数指针 #

如果需要保留非静态成员函数（比如要访问类的私有成员），可以把map的value类型改为成员函数指针：

template<typename T>
class HashTableOpeningAddress {
private:
    size_t linearProbing(T key, size_t i) {
        // 实现逻辑
        return i;
    }
    size_t quadraticProbing(T key, size_t i) {
        // 实现逻辑
        return i*i;
    }
    size_t doubleHashing(T key, size_t i) {
        // 实现逻辑
        return i * hash2(key);
    }

    // 修改map的value类型为成员函数指针
    std::map<std::string, size_t (HashTableOpeningAddress<T>::*)(T, size_t)> probeFunctionMap = {
        {"linearProbing", &HashTableOpeningAddress<T>::linearProbing},
        {"quadraticProbing", &HashTableOpeningAddress<T>::quadraticProbing},
        {"doubleHashing", &HashTableOpeningAddress<T>::doubleHashing}
    };

    // 调用示例
    void test() {
        auto func = probeFunctionMap["linearProbing"];
        // 必须通过this调用成员函数指针
        (this->*func)(10, 1);
    }
};

方案三：使用std::function包装（推荐，灵活性最高） #

如果希望调用方式更直观，同时保留访问非静态成员的能力，可以用std::function包装成员函数，结合lambda捕获this：

#include <functional> // 需要包含头文件

template<typename T>
class HashTableOpeningAddress {
private:
    size_t linearProbing(T key, size_t i) {
        // 实现逻辑
        return i;
    }
    size_t quadraticProbing(T key, size_t i) {
        // 实现逻辑
        return i*i;
    }
    size_t doubleHashing(T key, size_t i) {
        // 实现逻辑
        return i * hash2(key);
    }

    // 使用std::function作为map的value类型
    std::map<std::string, std::function<size_t(T, size_t)>> probeFunctionMap;

    // 在构造函数中初始化（因为需要捕获this，不能直接在类内初始化）
public:
    HashTableOpeningAddress() {
        probeFunctionMap = {
            {"linearProbing", [this](T key, size_t i) { return this->linearProbing(key, i); }},
            {"quadraticProbing", [this](T key, size_t i) { return this->quadraticProbing(key, i); }},
            {"doubleHashing", [this](T key, size_t i) { return this->doubleHashing(key, i); }}
        };
    }

    // 调用示例
    void test() {
        auto func = probeFunctionMap["linearProbing"];
        func(10, 1); // 直接调用，无需手动处理this
    }
};

内容的提问来源于stack exchange，提问作者JiangZiyang