可变元组模板构造函数在一个元组中混合左值和右值

Question

我想推迟一类（大）类的实例化，其中只有一小部分子集将被实例化。为此，我尝试在可变参数类中捕获构造函数的参数，该参数将它们存储在元组中。

我的问题是，我仅成功存储了引用或副本。但是，我需要立即将两种都转发给构造函数，否则会遇到范围问题。

#include <iostream>
#include <utility>
#include <tuple>
#include <vector>

// Interface of the classes which instanciation is being deferred.
struct OpItf {
    virtual void operator()() = 0;
    virtual ~OpItf() {}
};

struct Operator : public OpItf {
    int& _i;
    int _j;
    // Need both a lvalue reference and a rvalue.
    Operator(int& i, int j) : _i(i), _j(j) {}
    void operator()() {std::cout << _i << " " << _j << std::endl;}
    virtual ~OpItf() {}
};

// The interface of the class managing the actual instanciation.
template<class Itf>
struct ForgeItf {
        virtual Itf& instanciate() = 0;
        virtual ~ForgeItf() {}
};

template<class Itf, class Op, typename... Args>
struct Forge : public ForgeItf<Itf> {

    std::tuple<Args&&...> _args;
    Itf* _instanciated;

    Forge(Args&&... args) :
        _args(std::forward<Args>(args)...),
        _instanciated(nullptr)
    { }

    Itf& instanciate()
    {
        if(_instanciated) {
            delete _instanciated;
        }
        _instanciated = op_constructor(_args);
        return *_instanciated;
    }

    virtual ~Forge() { delete _instanciated; }

    template<class T>
    Op* op_constructor(T& args) { return new Op(std::make_from_tuple<Op>(args)); }
};

// A container of forges.
template<class Itf>
struct Foundry : std::vector< ForgeItf<Itf>* > {

        template<class Op, typename... Args>
        void add(Args&&... args)
        {
            auto pfo = new Forge<Itf,Op,Args&&...>(std::forward<Args>(args)...);
            this->push_back(pfo);
        }

        virtual ~Foundry() { for(auto p : *this) { delete p; } }
};

int main() {

    Foundry<OpItf> foundry;

    int iref = 1;

    // Store the constructors parameters.
    for(int j=0; j<3; ++j) {
        foundry.add< Operator >(iref,j);
    }

    // Change the referenced parameter before instanciations.
    iref = 2;

    // Actually instanciate.
    for(auto& forge : foundry ) {
        auto& op = forge->instanciate();
        op();
    }
}

使用右值Args...，构造函数获取值，但对i的引用是（不正确地）未更改：

1 0
1 1
1 2

使用转发引用Args&&...，构造函数会正确获取引用，但超出范围j：

2 1228009304
2 1228009304
2 1228009304

Answer 1

保留临时值alive的唯一方法是通过复制将它们存储到元组中。否则，通过存储引用，您可以将它们作为dangling。

您可以使用reference_wrapper来作为参考存储i。

更改：

  foundry.add< Operator >(std::ref(iref),j);  // wrap i into reference_wrapper 
  ---
  auto pfo = new Forge<Itf,Op,std::decay_t<Args>...>(std::forward<Args>(args)...);

使用std::decay_t<Args>...按值存储所有包装参数（复制reference_wrapper的操作很便宜）。

template<class Itf, class Op, typename... Args>
struct Forge : public ForgeItf<Itf> {

    std::tuple<Args...> _args;
    Itf* _instanciated;

    template<class ... Args2>
    Forge(Args2&&... args2) :
        _args(std::forward<Args2>(args2)...),
        _instanciated(nullptr)
    { }

因为Args被衰减，所以只需存储：tuple<Args...>，并让构造函数使用转发引用，以避免在调用构造函数时产生多余的副本。

作为输出：

2 1
2 2 
2 3

Live demo