类型擦除和可变参数模板化成员函数

Question

下面的例子是一个最小的例子，可能不是一个众所周知的成语的好例子。
它编译并且它是如此丑陋以便能够将它保持最小，因为问题不在于成语本身。

struct Foo {
    virtual void fn() = 0;
};

template<class T>
struct Bar: public Foo {
    void fn() override {
        T{}.fn();
    }
};

struct S {
    void fn() { }
};

int main() {
    Foo *foo = new Bar<S>{};
    foo->fn();
}

自一个小时前以来，我一直在苦苦挣扎的是如何更改它（或者甚至，如果存在替代习惯用法）以引入可变参数模板成员方法。
显然，我无法修改 Foo class 的 fn 函数，因为它是一个虚拟函数，虚拟说明符不与模板一起使用。这同样适用于 Bar 的 fn 规范，因为它必须以某种方式覆盖基础 class.

中的规范

注.

因为我强烈怀疑这个问题可能是有史以来最大的 XYProblem 问题之一，所以我还想对实际问题做一个简短的描述。

我有一个 class 公开了两个模板化成员方法：

第一个接受模板 class T 不会立即使用，而是应该 stored待会用到。
第二个接受可变数量的参数（它实际上是一个可变模板成员函数）并且这些参数应该完美地转发到新创建的 T 实例。

嗯，这个问题要复杂得多，但这是一个很好的近似，应该能让您了解目标是什么。

编辑

我猜它在某种程度上类似于高阶函数。
我的意思是，解决问题的方法确实是绑定第一个参数的模板化函数，但据我所知，这是不可能的，就像我目前探索的任何其他方法一样。
任何表达相同概念的可行解决方案？

Answer 1

我在评论中提到的是以下做法：

template<typename T> class Factory {

public:
    template<typename ...Args>
    auto construct(Args && ...args)
    {
        return T(std::forward<Args>(args)...);
    }
};

所以现在，您的第一个公开的 class 方法将是这样的：

template<typename T>
auto getFactory() {

    return Factory<T>();
}

所以：

auto factory=object.getFactory<someClass>();

// Then later:

factory.construct(std::string("Foo"), bar()); // And so on...

你也可以使用 operator() 而不是 construct()，所以第二部分就变成了：

factory(std::string("Foo"), bar()); // And so on...

正如我提到的，这并不是真正的类型擦除。你不能在这里使用类型擦除。

经过几分钟的思考，类型擦除不能在这里使用的原因是因为类型擦除的给定实例必须是 "self contained"，或者原子的，你需要做的是在您的情况下，将原子类型擦除分为两部分或两个 class 方法。

那不行。根据定义，类型擦除接受一个类型并 "erases" 它。一旦您的第一个函数类型擦除其 class 方法模板参数，您最终得到的是某种不透明的类型擦除对象。被类型擦除的内容不再对外界可用。但是您仍然没有类型擦除您的构造函数参数，这发生在其他地方。

您可以对模板 class 和构造函数参数一起进行类型擦除。您不能分别对模板 class 和构造函数参数进行类型擦除，然后以某种方式再次对结果进行类型擦除 .

简单的基于工厂的方法，如我概述的方法，将是最接近类型擦除的结果，如果你想要的类型擦除的两半出现在同一范围内，所以你实际上可以避免类型擦除，而是依赖编译器生成的膨胀。

Answer 2

我也同意你不能在这里做你想做的事情。我会 post 我认为最接近的选项（至少是与 SamVarshavchik 的回答不同的接近选项）。
我不希望这个答案能准确解决你的问题，但希望它能给你一些想法。

    struct Delay // I have no idea what to call this
    {
        template <class T>
        void SetT()
        {
            function_ = [](boost::any params){return T(params);}
        }

        template <class ... Args>
        boost::any GetT(Args ... args)
        {
            return function_(std::make_tuple(args...));
        }

      private:
        std::function<boost::any(boost::any)> function_;
    };

这个明显的限制是任何调用 GetT 的人都必须知道 T 已经是什么，尽管您可以查询 boost::any 对象以获得 type_info 的 class 如果有帮助的话。此处的另一个限制是您必须传入带有 boost::any 对象的 T 并知道如何处理它。如果你不能让 T 这样做，那么你可以像这样更改 SetT（或创建一个新的成员函数）：

    template <class F>
    SetTFactory(F f)
    {
        function_ = f;
    }

然后像这样使用它：

    Delay d;
    d.SetTFactory([](boost::any s){return std::string(boost::any_cast<const char*>(s));});
    auto s = d.GetT("Message");
    assert(s.type() == typeid(std::string));

这当然会引入一整套新的难题来应对，所以我不知道这个解决方案对您来说是否可行。我认为不管其他任何事情，您将不得不重新考虑您的设计。

类型擦除和可变参数模板化成员函数

Type erasure and variadic templated member function

c++

templates

type-erasure

variadic-templates

c++11