在模板中存储右值引用的危险

Question

考虑以下代码：

#include <functional>

template<class T>
class factory {
public:
    factory(T &&t) : t_(std::forward<T>(t)) {}

private:
    T &&t_;
};

template<class T>
factory<T> make_factory(T &&t) {
    return factory<T>(std::forward<T>(t));
}

int main(){
    int i = 3;
    auto bar = make_factory(i); //now it will store int &
    auto foo = make_factory(5); //now will store int &&
    return 0;
}

这当然是对代码的简化，但显示了我的一般想法——我正在考虑存储对右值的引用。据我所知，在第一种情况下，推导的类型将为int &，因此工厂将在离开范围之前有效（由于引用折叠）。我的问题是

1. foo 对象是否会导致未定义的行为？
2. 如果不是，存储的右值引用的有效期是多久（我的意思是，它的范围是多少）？
3. 我是否缺少任何注意事项？

编辑： 我认为这已经足够了，但我看到我必须澄清。我想实现这样的目标：

template<class T>
class factory {
public:
    factory(T &&t) : t_(std::forward<T>(t)) {}

    auto make() const & {
        return wrap(t_);
    }

    auto make() && {
       return wrap(/*what here, move(t_), forward<T>(t_) ?*/);
    }
private:
    T t_;//or maybe T&& here?
};

我不想复制该成员，除非我真的必须这样做。我想做一些类似通过factory 类转发的事情。

Answer 1

一般这样做：

template<class T>
class factory {
public:
  factory(T &&t) : t_(std::forward<T>(t)) {}

private:
  T t_; // could be a lvalue ref
};

它只是工作。真的。是的，这种情况也是如此。

右值不应超过其封闭语句；所以你的制造工厂不应该返回一个包含右值引用的结构。