c++ - 派生自另一个类模板类型推导的类模板

Question

我正在尝试编写一个仿函数内存器以节省重复昂贵的函数调用的时间。在我的类(class)设计中，我正在努力寻找一个简单的界面。

使用这个 Functor 基类:

template <typename TOut, typename TIn>
class Functor {
public:
    virtual
    ~Functor() {
    }

    virtual
    TOut operator()(TIn input) = 0;
};

我现在想写一个类来封装和内存一个仿函数。除了封装一个 Functor 之外，MemoizedFunctor 本身就是一个 Functor。这导致具有 3 个模板参数。

这是一个工作示例:

#include <unordered_map>

template <typename F, typename TOut, typename TIn>
class MemoizedFunctor : public Functor<TOut, TIn> {
public:
    MemoizedFunctor(F f) : f_(f) {
    }

    virtual
    ~MemoizedFunctor() {
    }

    virtual
    TOut operator()(TIn input) override {
        if (cache_.count(input)) {
            return cache_.at(input);
        } else {
            TOut output = f_(input);
            cache_.insert({input, output});
            return output;
        }
    }

private:
    F f_;
    std::unordered_map<TIn, TOut> cache_;
};

class YEqualsX : public Functor<double, double> {
public:
    virtual
    ~YEqualsX() {
    }

    double operator()(double x) override {
        return x;
    }
};

int main() {
    MemoizedFunctor<YEqualsX, double, double> f((YEqualsX())); // MVP

    f(0); // First call
    f(0); // Cached call

    return 0;
}

我觉得必须有一种方法可以避免指定所有 3 个模板参数。给定传递给 MemoizedFunctor 的构造函数的函数，我认为可以推导出所有三个模板参数。

我不确定如何重写类以便使用它不需要所有模板规范。

我尝试使用指向 Functor 的智能指针作为 MemoizedFunctor 中的成员变量。这消除了第一个模板参数，但现在类的用户必须将智能指针传递给 MemoizedFunctor 类。

总而言之，我希望 MemoizedFunctor 的所有模板参数在构造时自动推导。我相信这是可能的，因为在构建时所有模板参数都是明确的。

Answer 1

In summary, I would like to have all the template arguments of MemoizedFunctor be automatically be deduced on construction. I believe this is possible because on construction all template arguments are unambiguous.

如果我没理解错的话，第一个模板类型为MemoizedFunctor曾经是Functor<TOut, TIn> ，或继承自某些 Functior<TOut, TIn> 的东西, 其中TOut和 TIn是 MemoizedFunctor 的第二个和第三个模板参数.

在我看来，您正在寻找推导指南。

为了推导出第二个和第三个模板参数，我建议声明(不需要定义，因为仅在 decltype() 内部使用)以下几个函数

template <typename TOut, typename TIn>
constexpr TIn getIn (Functor<TOut, TIn> const &);

template <typename TOut, typename TIn>
constexpr TOut getOut (Functor<TOut, TIn> const &);

现在，使用 decltype()和 std::declval() , 用户定义的推演指南就变成了

template <typename F>
MemoizedFunctor(F)
   -> MemoizedFunctor<F,
                      decltype(getOut(std::declval<F>())),
                      decltype(getIn(std::declval<F>()))>;

下面是一个完整的编译示例

#include <unordered_map>

template <typename TOut, typename Tin>
class Functor
 {
   public:
    virtual ~Functor ()
     { }

    virtual TOut operator() (Tin input) = 0;
 };

template <typename TOut, typename TIn>
constexpr TIn getIn (Functor<TOut, TIn> const &);

template <typename TOut, typename TIn>
constexpr TOut getOut (Functor<TOut, TIn> const &);

template <typename F, typename TOut, typename TIn>
class MemoizedFunctor : public Functor<TOut, TIn>
 {
   public:
      MemoizedFunctor(F f) : f_{f}
       { }

      virtual ~MemoizedFunctor ()
       { }

      virtual TOut operator() (TIn input) override
       {
         if ( cache_.count(input) )
            return cache_.at(input);
         else
          {
            TOut output = f_(input);
            cache_.insert({input, output});
            return output;
          }
       }

   private:
      F f_;
      std::unordered_map<TIn, TOut> cache_;
 };

class YEqualsX : public Functor<double, double>
 {
   public:
      virtual ~YEqualsX ()
       { }

      double operator() (double x) override
       { return x; }
 };

template <typename F>
MemoizedFunctor(F)
   -> MemoizedFunctor<F,
                      decltype(getOut(std::declval<F>())),
                      decltype(getIn(std::declval<F>()))>;

int main ()
 {
   MemoizedFunctor f{YEqualsX{}};

   f(0); // First call
   f(0); // Cached call
 }

-- 编辑 --

Aschepler 在评论中指出，此解决方案可能存在一个缺点:某些类型无法从函数返回。

例如，函数不能返回 C 风格的数组。

这不是推导 TOut 的问题(由 operator() 返回的类型)正是因为是方法返回的类型，所以也可以由 getOut() 返回.

但这可能(一般来说)是 TIn 的问题: 如果 TIn例如，int[4] (在这种情况下不能，因为用作无序映射的键，但我再说一遍，一般来说)，int[4]无法通过 getIn() 返回.

您可以绕过这个问题 (1) 添加一个类型包装器结构，如下所示

template <typename T>
struct typeWrapper
 { using type = T; };

(2) 修改getIn()返回 wrapper TIn

template <typename TOut, typename TIn>
constexpr typeWrapper<TIn> getIn (Functor<TOut, TIn> const &);

和(3)修改推导指南以提取TIn从包装

template <typename F>
MemoizedFunctor(F)
   -> MemoizedFunctor<F,
                      decltype(getOut(std::declval<F>())),
                      typename decltype(getIn(std::declval<F>()))::type>;