模板功能图

问题描述

我想用包含功能的std::map键制作一个std::string。 这些函数应该为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);

• 这是可能的吗？还有更好的主意吗？

解决方法

我认为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之前，您将需要定义所有函数模板，或者将自己限制为一组预定的类型。我不知道在定义后用无限函数模板实例填充无限funcMap实例的方法。

,

您可以使用通用lambda：

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

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

,

由于我们对您的最终目标了解不多，因此无法确定是否有解决问题的简便方法。当您面对一种无法解决的问题时，可以通过问自己：遵循务实的程序员原则“切开高地结”：

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

也就是说，我认为Caleth解决方案是最简单的。如果您想要一个包含整个重载集的单个映射的解决方案，请使用以下概念证明（警告：它有很多缺陷，仅在您的情况下有效）。

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

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,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++;
    }
};

下一步是在一个类中收集您感兴趣的操作的所有专业化内容：

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

在内部，我们使用std::variant模拟一种异构地图。我们将其包装到一个类中，以提供一个简单易用的接口：

// 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。

致谢。