Question

看看这段代码：

struct TestStructure
{
    char mName[256];
    int mSize;

    // Store function pointer with templated argument.
    // Store function pointer with templated return type.
};

class TestClass
{
public:
    void setTestInt(const int& value) { mTestInt = value; }
    const int& getTestInt() const { return mTestInt; }
    void setTestFloat(const float& value) { mTestFloat = value; }
    const float& getTestFloat() const { return mTestFloat; }

    static TestStructure* getTestStructure()
    {
        static TestStructure testStructure[] =
        {
            {"mTestInt", sizeof(int), /* setTestInt pointer, getTestInt pointer */},
            {"mTestFloat", sizeof(float), /* setTestFloat pointer, getTestFloat pointer */}
        };

        return testStructure;
    }

private:
    int mTestInt;
    float mTestFloat;
};

我想要实现的是将 TestStructure 存储在类的各种getter和setter的函数指针中（并且它必须适用于任何类型的类型）。

有办法吗？

Answer 1

看起来好像差不多2015年了，你现在可能只是在学习C ++：使用符合C ++ 14的编译器，这段代码就可以了。

只需使用元组存储函数指针

template<typename ... Types>
class test_class{
    public:
        template<typename T>
        void set(const T &t){std::get<T>(m_values) = t;}

        template<typename T>
        T &get(){return std::get<T>(m_values);}

        using getters_setters_type = std::pair<std::tuple<Types &(test_class::*)()...>, std::tuple<void (test_class::*)(const Types&)...>>;

        getters_setters_type &getters_and_setters(){
            getters_setters_type ret{
                std::make_tuple(&test_class::get<Types>...),
                std::make_tuple(&test_class::set<Types>...)
            };
            return ret;
        }

    private:
        std::tuple<Types...> m_values;
};

然后作为一个例子

int main(){
    test_class<int, float> test_if;
    auto &&getters_and_setters = test_if.getters_and_setters();

    std::function<void(const int&)> set_int(std::bind(std::get<0>(std::get<0>(getters_and_setters)), &test_if, std::placeholders::_1));
    std::function<int&()> get_int(std::bind(std::get<0>(std::get<1>(getters_and_setters)), &test_if));

    // set int to 5
    set_int(5);

    // check it worked
    if(get_int() != 5)
        std::cerr << "dub tee eff, man!" << std::endl;
}

现在，我承认;这看起来相当令人作呕......但是它会按照你的要求行事：D将tuple放入struct而不是pair将是微不足道的。

修改

我无法将答案留在那种病态;可以轻松编写一些辅助函数来提高可读性：

template<typename T, typename ... Types> std::function<T&()> get_getter(test_class<Types...> &t){ return std::bind( std::get<T&(test_class<Types...>::*)()>(std::get<0>(t.getters_and_setters())), &t ); } template<typename T, typename ... Types> std::function<void(const T&)> get_setter(test_class<Types...> &t){ return std::bind( std::get<void(test_class<Types...>::*)(const T&)>(std::get<1>(t.getters_and_setters())), &t, std::placeholders::_1 ); }

然后在你的主要功能中你可以写

int main(){ test_class<int, float> test_if; auto get_int = get_getter<int>(test_if); auto set_int = get_setter<int>(test_if); set_int(5); if(get_int() != 5) std::cerr << "dub tee eff, man!" << std::endl; }

看起来并不太糟糕！

带有模板参数和返回类型的函数指针

1 个答案: