模板函数图

Question

我想用 std::string 键制作一个包含功能的 std::map。这些函数应该是 templates 以便使用不同的数值：

template <typename T> T (*pfunc)(T,T);

地图声明如下所示：

std::map<std::string, pfunc> funcMap;

我知道我需要一个模板参数列表用于pfunc，但我真的不知道该怎么做。

[编辑]

统计评论。我希望能够：创建函数模板为：

template <typename T> 
T myMax(T x, T y) 
{ 
   return (x > y)? x: y; 
}

或

template <typename T> 
T myMin(T x, T y) 
{ 
   return (x < y)? x: y; 
}

然后将其添加到我的地图：funcMap["myMax"] = myMax; 或 funcMap["myMin"] = myMin;
并将其用作：

funcMap["myMax"]<int>(3,4);
funcMap["myMax"]<float>(3.1,4.5);
funcMap["myMin"]<int>(3,4);
funcMap["myMin"]<float>(3.1,4.5);

这可能吗？有更好的主意吗？

Answer 1

我认为 best you will get 是

template <typename T> 
T myMax(T x, T y) 
{ 
   return (x > y)? x: y; 
} 

template <typename T> 
T myMin(T x, T y) 
{ 
   return (x < y)? x: y; 
} 

template <typename T> using pfunc = T(*)(T, T);

template <typename T> std::map<std::string, pfunc<T>> funcMap = { 
    { "myMax", myMax }, 
    { "myMin", myMin } 
};

您需要在定义 funcMap 之前定义所有函数模板，或者将自己限制在 pre-determined 类型集。我不知道在定义后用无限函数模板实例填充无限 funcMap 实例的方法。

Answer 2

您可以使用通用 lambda：

[](auto x, auto y) { return myMax(x, y); }

但是，这不是一个函数指针，而是一个对象。

Answer 3

由于我们对您的最终目标知之甚少，因此我们无法确定您的问题是否有简单的解决方法。当你面对一种无法解决的问题时，你可以通过问问自己来遵循被称为“快刀斩乱麻”的实用程序员原则：

有没有更简单的方法？
我解决的问题对吗？
为什么这是个问题？
是什么让它变得困难？
我必须这样做吗？
有必要做吗？

也就是说，我认为 Caleth 解决方案是最直接的。如果你想要一个包含整个重载集的单个映射的解决方案，这里是一个概念证明（警告：它有很多缺陷并且只适用于你的情况）。

首先，您需要一些助手来检测 class 是否具有正确的函数调用运算符重载：

namespace helpers {
    // simplify is_detected pattern (see https://en.cppreference.com/w/cpp/experimental/is_detected)
    template <typename Dummy, template <typename...> typename Op, typename... Args>
    struct is_detected : std::false_type {};

    template <template <typename...> typename Op, typename... Args>
    struct is_detected<std::void_t<Op<Args...>>, Op, Args...> : std::true_type {};

    template <template <typename...> typename Op, typename... Args>
    constexpr bool is_detected_v = is_detected<void, Op, Args...>::value;

    // Check if a class has an overloaded function call operator with some params
    template <typename T, typename... Args>
    using has_fcall_t = decltype(std::declval<T>()(std::declval<Args>()...));

    template <typename T, typename... Args>
    constexpr bool has_fcall_v = is_detected_v<has_fcall_t, T, Args...>;
}

然后，定义基本的数值运算：

template <typename T>
struct Additionner {
    T operator()(T a, T b) {
        return a + b;
    }
};

template <typename T>
struct Multiplier{
    T operator()(T a, T b) {
        return a * b;
    }
};

template <typename T>
struct Incrementor {
    T operator()(T a) {
        return a++;
    }
};

下一步是在单个 class:

中收集您感兴趣的操作的所有专业化

// Used to store many overloads for the same operations
template <typename... Bases>
struct NumOverloader : Bases...
{
    using Bases::operator()...;
};

在内部，我们使用一个std::variant来模拟一种异构映射。我们将它包装成一个 class 以提供一个简单的接口来使用：

// wrapper around a variant that expose a universal function call operator
template <typename... Ts>
class NumDispatcher {
public:
    NumDispatcher() = default;

    template <typename T> // Fine tuning needed (see https://mpark.github.io/programming/2014/06/07/beware-of-perfect-forwarding-constructors/)
    NumDispatcher(T&& t) : m_impl(std::forward<T>(t)){
    }

    // visit the variant
    template <typename... Args>
    auto operator()(Args... args) {
        using type = std::common_type_t<Args...>;
        type t{};
        std::visit([&](auto&& visited) {
            using vtype = std::decay_t<decltype(visited)>;
            if constexpr(helpers::has_fcall_v<vtype, Args...>)
                t = std::forward<vtype>(visited)(args...);
            else
                throw std::runtime_error("bad op args");
        }, m_impl);
        return t;
    }
private:
    using Impl = std::variant<Ts...>;
    Impl m_impl;
};

最后一步是定义映射：

// Here you need to know at compile-time your overloads
using MyIncrementors = NumOverloader<Incrementor<int>, Incrementor<unsigned>>;
using MyAdditionners = NumOverloader<Additionner<int>, Additionner<double>>;
using MyMultipliers = NumOverloader<Multiplier<int>, Multiplier<double>>;

using MyValueType = NumDispatcher<MyIncrementors, MyAdditionners, MyMultipliers>;
using MyMap = std::map<std::string, MyValueType>;

然后，你就可以玩了：

Num::MyMap m;
m["add"] = Num::MyAdditionners{};
m["mul"] = Num::MyMultipliers{};
m["inc"] = Num::MyIncrementors{};

auto d = m["add"](2.4, 3.4);
std::cout << d << std::endl;
// auto d2 = m["add"](1.3f, 2); // throw no overload match
std::cout << m["inc"](1) << std::endl;
//std::cout << m["inc"](1,1) << std::endl; // throw no overload match
std::cout << m["mul"](3, 2) << std::endl;

DEMO HERE.

此致。

模板函数图

Map of template functions

c++

templates

typedef

stdmap

c++17