容器中的引用？

Question

#include <iostream>
#include <string>

struct Foo {
  void init(int num, const std::string& txt)
  {
    this->num = num;
    this->txt = txt;
  }

  int num;
  std::string txt;
};

int main()
{
  auto codegen1 = [](std::pair<int, const std::string&> package) -> Foo* {
    auto foo = new Foo;
    foo->init(package.first, package.second); //here string goes out of scope, exception
    return foo;
  };

  auto codegen2 = [](int num, const std::string& txt) -> Foo* {
    auto foo = new Foo;
    foo->init(num, txt);
    return foo;
  };

  auto foo = codegen1({3, "text"});
  auto foo2 = codegen2(3, "text");
  std::cout << foo->txt;
} 

我知道应该使用常量std::pair & ，但我想知道为什么这种方法不起作用。

Answer 1

第1部分：这看起来一看就坏了。

“text”不是字符串，而是用于创建临时std::string对象的文本，然后该对象用于初始化std::pair。因此，您会认为，在引用该字符串时，只暂时需要该字符串（即在构造std::pair之前）是有意义的。

第二部分：但它不应该被打破。

那么，为什么在codegen1()的情况下字符串会过早地被销毁呢？从“text”到std::string的转换不是作为子表达式发生的，而是作为一个单独的函数的一部分，该函数使用自己的作用域进行调用。

这里使用的std::pair的构造函数是：

// Initializes first with std::forward<U1>(x) and second with std::forward<U2>(y).
template< class U1 = T1, class U2 = T2 >
constexpr pair( U1&& x, U2&& y );

构造函数获取“text”作为参数，并且std::string的构造是在std::pair的构造函数中进行的，因此当我们从该构造函数返回时，作为该过程的一部分创建的临时变量将被清除。

我们怎么解决这个问题？

有几个选择：

强制转换在正确的“级别”发生：

auto foo = codegen1({3, std::string("text")});

using namespace std::literals::string_literals;
auto foo = codegen1({3, "text"s});

auto codegen1 = [](std::pair<int, std::string_view> package) -> Foo* {
...
}

struct Foo {
  Foo(int num, std::string txt)
    : num(num)
    , txt(std::move(txt))
  {}

  int num;
  std::string txt;
};

int main()
{
  auto codegen1 = [](std::pair<int, std::string> package) {
    return std::make_unique<Foo>(package.first, std::move(package.second));
  };

  auto foo = codegen1({3, "text"});

  std::cout << foo->txt;
}