模板类型擦除

Question

我想知道是否有使用 C++17 标准编写类似以下代码的实用方法：

#include <string>
#include <functional>
#include <unordered_map>

template <class Arg>
struct Foo
{
    using arg_type = Arg;
    using fun_type = std::function< void(Arg&) >;
    fun_type fun;
    
    void call( Arg& arg ) { fun(arg); }
};

struct Bar
{
    using map_type = std::unordered_map<std::string,Foo>; // that's incorrect
    map_type map;
    
    auto& operator[] ( std::string name ) { return map[name]; }
};

在上面的代码中，Foo 类的模板参数对应于某个不返回任何内容的一元函数的输入类型。具有不同模板类型的Foo 的不同实例对应于采用不同类型参数的函数。 Bar 类只是旨在为这些函数分配一个名称，但显然当前映射的声明是不正确的，因为它需要知道 Foo 的模板类型。

是吗？

Answer 1

不幸的是，通过编译时检查来执行此操作是不可行的。但是，您可以通过运行时检查来提供该功能。

一个映射的值类型只能是一个单一的类型，Foo<T> 是每个T 的不同类型。但是，我们可以通过为每个Foo<T> 提供一个公共基类、拥有指向它的指针映射并使用虚函数将call() 分派给适当的子类来解决这个问题。

为此，参数的类型也必须始终相同。正如@MSalters 所述，std::any 可以提供帮助。

最后，我们可以使用 pimpl 模式包装所有内容，这样看起来只有一个整洁的Foo 类型：

#include <cassert>
#include <string>
#include <functional>
#include <any>
#include <unordered_map>
#include <memory>

struct Foo {
public:
  template<typename T, typename FunT>
  void set(FunT fun) {
      pimpl_ = std::make_unique<FooImpl<T, FunT>>(std::move(fun));
  }

  // Using operator()() instead of call() makes this a functor, which
  // is a little more flexible.
  void operator()(const std::any& arg) {
      assert(pimpl_);
      pimpl_->call(arg);
  }
  
private:
    struct IFooImpl {
      virtual ~IFooImpl() = default;
      virtual void call( const std::any& arg ) const = 0; 
    };

    template <class Arg, typename FunT>
    struct FooImpl : IFooImpl
    {
        FooImpl(FunT fun) : fun_(std::move(fun)) {}
        
        void call( const std::any& arg ) const override {
            fun_(std::any_cast<Arg>(arg));
        }

    private:
        FunT fun_;
    };

  std::unique_ptr<IFooImpl> pimpl_;
};


// Usage sample
#include <iostream>

void bar(int v) {
    std::cout << "bar called with: " << v << "\n";
}

int main() {
    std::unordered_map<std::string, Foo> table;

    table["aaa"].set<int>(bar);

    // Even works with templates/generic lambdas!
    table["bbb"].set<float>([](auto x) {
        std::cout << "bbb called with " << x << "\n";
    });

    table["aaa"](14);
    table["bbb"](12.0f);
}

see on godbolt