避免使用表达式模板#define

Question

对于以下代码，“hello2”不会显示，因为第 3 行创建的临时字符串在第 4 行执行之前就消失了。在第 1 行中使用 #define 可以避免此问题，但是有没有办法在不使用 #define 的情况下避免此问题？ （C++11 代码没问题）

#include <iostream>
#include <string>

class C
{
public:
  C(const std::string& p_s) : s(p_s) {}
  const std::string& s;
};

int main()
{
  #define x1 C(std::string("hello1")) // Line 1
  std::cout << x1.s << std::endl; // Line 2

  const C& x2 = C(std::string("hello2")); // Line 3
  std::cout << x2.s << std::endl; // Line 4
}

澄清：

请注意，我相信 Boost uBLAS 存储引用，这就是为什么我不想存储副本。如果你建议我按值存储，请解释为什么Boost uBLAS是错误的并且按值存储不会影响性能。

Answer 1

按引用存储的表达式模板通常是为了性能而这样做，但需要注意的是，它们只能用作临时

模板取自 Boost.Proto 的文档（可用于创建表达式模板）：

注意 精明的读者会注意到上面定义的对象 y 将保留对临时 int 的悬空引用。在 Proto 解决的各种高性能应用程序中，通常会在任何临时对象超出范围之前构建和评估表达式树，因此这种悬空引用情况通常不会出现，但确实需要注意。 Proto 提供了用于深度复制表达式树的实用程序，因此它们可以作为值类型传递，而无需担心悬空引用。

在您最初的示例中，这意味着您应该这样做：

std::cout << C(std::string("hello2")).s << std::endl;

这样 C 临时文件永远不会比 std::string 临时文件寿命更长。或者，您可以将 s 设为非引用成员，正如其他人指出的那样。

既然你提到了 C++11，将来我希望表达式树按值存储，使用移动语义来避免昂贵的复制，并且像 std::reference_wrapper 这样的包装器仍然提供按引用存储的选项。这与 auto 配合得很好。

代码的可能 C++11 版本：

class C
{
public:
    explicit
    C(std::string const& s_): s { s_ } {}

    explicit
    C(std::string&& s_): s { std::move(s_) } {}

    std::string const&
    get() const& // notice lvalue *this
    { return s; }

    std::string
    get() && // notice rvalue *this
    { return std::move(s); }

private:
    std::string s; // not const to enable moving
};

这意味着像 C("hello").get() 这样的代码只会分配内存一次，但仍然可以很好地使用

std::string clvalue("hello");
auto c = C(clvalue);
std::cout << c.get() << '\n'; // no problem here

Answer 2

但是有没有办法在不使用#define的情况下避免这个问题？

是的。

将您的类定义为：（不存储引用）

class C
{
public:
  C(const std::string & p_s) : s(p_s) {}
  const std::string s; //store the copy!
};

存储副本！

演示： http://www.ideone.com/GpSa2

---

您的代码的问题是 std::string("hello2") 创建一个临时对象，只要您在 C 的构造函数中，它就保持活动状态，之后临时对象被销毁，但您的对象x2.s stills 指向它（死亡对象）。

Answer 3

编辑后：

通过引用存储有时危险且容易出错。仅当您 100% 确定变量引用在其死亡之前永远不会超出范围时才应执行此操作。

C++ string 非常优化。在您更改字符串值之前，所有值都将仅引用同一字符串。要测试它，您可以重载operator new (size_t)并放置调试语句。对于同一字符串的多个副本，您将看到内存分配仅发生一次。

您的类定义不应该通过引用存储，而应该通过值存储，

class C {
  const std::string s;  // s is NOT a reference now
};

如果这个问题是为了一般意义（而不是特定于字符串），那么最好的方法是使用动态分配。

class C {
  MyClass *p;
  C() : p (new MyClass()) {}  // just an example, can be allocated from outside also
 ~C() { delete p; }
};

Answer 4

如果不考虑 BLAS，表达式模板通常会大量使用您甚至不应该知道其存在的类型的临时对象。如果 Boost 在他们的引用中存储这样的引用，那么他们将遇到与您在这里看到的相同的问题。但是，只要这些临时对象仍然是临时的，并且用户不存储它们供以后使用，一切都很好，因为它们引用的临时对象与临时对象一样保持活动状态。技巧是当中间对象变成用户存储的最终对象时执行深层复制。您在这里跳过了最后一步。

简而言之，这是一个危险的举动，只要你的库的用户不做任何愚蠢的事情，这就是完全安全的。我不建议使用它，除非您有明确的需求，并且您很清楚后果。即便如此，可能还有更好的选择，我从未以任何严肃的身份使用过表达式模板。

顺便说一句，由于您标记了此 C++0x，auto x = a + b; 似乎是您的代码的用户可以做的那些“愚蠢”的事情之一，使您的优化变得危险。