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();
}

我一小时前所挣扎的是如何改变它（甚至，如果存在替代习语），引入可变参数模板成员方法。
显然，我无法修改fn类的Foo函数，因为它是虚拟的，虚拟说明符并不与模板一起使用。这同样适用于fn的{{1}}规范，因为它必须以某种方式覆盖基类中的那个。

注意。

因为我强烈怀疑这个问题可能是有史以来最伟大的 XYProblem 之一，我还想简要介绍一下实际问题。

我有一个暴露两个模板化成员方法的类：

第一个接受未立即使用的模板类Bar，而应以某种方式存储以便以后使用。
第二个接受可变数量的参数（它实际上是一个可变参数化模板成员函数），这些参数应该完美地转发到新创建的T实例。

嗯，这个问题要复杂得多，但这是一个很好的近似，应该让你知道目标是什么。

修改

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

Answer 1

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

template<typename T> class Factory {

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

所以现在，你的第一个暴露类方法将是这样的：

template<typename T>
auto getFactory() {

    return Factory<T>();
}

所以：

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

// Then later:

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

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

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

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

在考虑了这几分钟之后，这里不能使用类型擦除的原因是因为类型擦除的给定实例必须是“自包含”或原子，并且您需要做的是打破原子在你的情况下，将类型擦除分为两部分或两类方法。

那不行。根据定义，类型擦除采用一种类型并“擦除”它。一旦你的第一个函数类型 - 擦除它的类方法模板参数，你最终得到的是某种不透明的，类型擦除的对象。外部世界不再提供类型擦除的内容。但是你仍然没有对你的构造函数参数进行类型擦除，这些参数会发生在其他地方。

您可以一起键入 - 擦除模板类和构造函数参数。您不能单独键入 - 擦除模板类和构造函数参数，然后以某种方式键入 - 擦除结果。

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

Answer 2

我也同意你不能在这里做到你想要的。我将发布我认为最接近的选项（至少是一个与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它的课程如果有帮助的话。这里的另一个限制是你必须传递T一个boost::any对象并知道如何处理它。如果您不能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));

这当然会引入一系列新的难点，所以我不知道这个解决方案对你有多可行。我认为无论如何，你都需要重新考虑你的设计。

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

2 个答案: