7

阅读这个关于从函数返回右值引用的答案让我思考，如何id在 C++0x 中编写函数。

基本上，我想id成为一个什么都不做的函数，一个对程序没有明显影响的函数。

我的第一次尝试如下：

#include <iostream>

class X
{
public:
  X(std::string&& s) : s(std::move(s)) {};
  X(const std::string& s) : s(s) {};
  std::string s;
  ~X() { std::cout << "Destroying: " << s << std::endl; }
private:
  X(const X&) {};
  X(X&&) {};
};

template <class T>
T&& id(T&& x) { return static_cast<T&&>(x); }

int main()
{
  auto&& x1 = X("x1");
  std::cout << "Line 1" << std::endl;
  auto&& x2 = id(X("x2"));
  std::cout << "Line 2" << std::endl;
}

但是，我担心在这种情况下，x2 是一个悬空引用，因为X("x2")在“第 2 行”执行之前被销毁。

所以在这里，很明显id有一个可观察的效果。

如何id在 C++0x 中编写函数，该函数特别适用于没有移动/复制构造函数的类型。

4

3 回答 3

7

你不能。通常，您不应该编写返回右值引用的函数 - 正如您正确指出的那样，您不能将临时的生命周期延长得足够长。

于 2011-08-23T14:37:21.177 回答
0

你想要做的叫做完美转发，STL中有一个函数可以做到这一点：

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept
{
    return static_cast<T&&>(t)
}
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept
{
    return static_cast<T&&>(t)
}

您需要remove_reference避免引用崩溃。使用它时，您必须指定要转发的对象的类型：

std::forward<X>(X("x2"));
于 2011-08-23T15:27:07.170 回答
0

编程语言中的大多数东西都不是完全免费的。除非您正在编写仅编译时的代码，否则编写标识函数不太可能是免费的。

让我们稍微修改一下您的代码：

#include <algorithm>
#include <iostream>

template <typename T>
T id1(T&& t)
{
  return t;
}

template <typename T>
T id2(T&& t)
{
  return std::move(t);
}


class X
{
public:
  X() 
    { output0("Xdef"); } 
  X(std::string const& s) : label_(s)
    { output1("Xstr",s); } 
  X(X const& x) : label_(x.label_)
    { output1("Xcopy", x); } 
  X(X&& x) : label_(std::move(x.label_))
    { output1("Xmove", x); } 

  X& operator =(X const& x) 
  {
    output1("operator =copy", x);
    label_ = x.label_;
    return *this;
  } 

  X& operator =(X&& x) 
  { 
    using std::swap;
    output1("operator =move", x);
    swap(label_, x.label_);
    return *this;
  } 

  ~X() 
    { output0("~X"); }

private:
  void output_id() const
  {
    std::cout << this << '[' << label_ << "]"; 
  }

  void output0(std::string const& name) const
  {
    output_id();
    std::cout << ": " << name << "()" << std::endl; 
  }

  void output1(std::string const& name, std::string const& str) const
  {
    output_id();
    std::cout 
      << ": " << name 
      << "(\"" << str 
      << "\")" << std::endl;
  }

  void output1(std::string const& name, X const& arg) const
  {
    output_id();
    std::cout << ": " << name << '('; 
    arg.output_id();
    std::cout << ')' << std::endl;
  }

  std::string label_;
};

int main()
{
  {
    std::cout << "CASE A:\n";
    auto x = X("x1");
  }
  std::cout << "\n";
  {
    std::cout << "CASE B:\n";
    auto x = id1(X("x2"));
  }
  std::cout << "\n";
  {
    std::cout << "CASE C:\n";
    auto x = id2(X("x3"));
  }
  std::cout << "\n";
  {
    std::cout << "CASE D:\n";
    X x = id1(X("x4"));
  }
  std::cout << "\n";
  {
    std::cout << "CASE E:\n";
    X x = id2(X("x5"));
  }
}

并在运行时输出（使用 GCC v4.8 快照）：

$ ./a.out 
CASE A:
0x7fff411fc530[x1]: Xstr("x1")
0x7fff411fc530[x1]: ~X()

CASE B:
0x7fff411fc540[x2]: Xstr("x2")
0x7fff411fc520[x2]: Xcopy(0x7fff411fc540[x2])
0x7fff411fc540[x2]: ~X()
0x7fff411fc520[x2]: ~X()

CASE C:
0x7fff411fc540[x3]: Xstr("x3")
0x7fff411fc520[x3]: Xmove(0x7fff411fc540[])
0x7fff411fc540[]: ~X()
0x7fff411fc520[x3]: ~X()

CASE D:
0x7fff411fc540[x4]: Xstr("x4")
0x7fff411fc520[x4]: Xcopy(0x7fff411fc540[x4])
0x7fff411fc540[x4]: ~X()
0x7fff411fc520[x4]: ~X()

CASE E:
0x7fff411fc540[x5]: Xstr("x5")
0x7fff411fc520[x5]: Xmove(0x7fff411fc540[])
0x7fff411fc540[]: ~X()
0x7fff411fc520[x5]: ~X()
$

案例 A 简单地调用 X 的构造函数。=在这个例子中，等效于将 的右侧传递=给 X，即，它不是赋值。

案例 B 调用id1()不移动其返回参数。由于返回的值没有在 id() 的调用堆栈上定义，并且该值是一个左值（保存一个右值），因此它不会在返回时自动移动，因此被复制了。

案例 C 调用id2()在返回时调用移动构造函数。

案例 D 和 E 分别与案例 B 和 C 相同，除非auto您对此持怀疑态度。

移动应该被视为优化的副本，并且在最坏的情况下与副本一样糟糕（尽管它们通常会好得多）。即使是最佳移动也有成本（例如，将一些数据（通常）从一个堆栈帧复制到另一个堆栈帧）。在运行时代码中完全避免复制/移动的唯一方法是返回值优化和复制 ellison 适合编译器使用。

于 2012-07-14T00:37:45.937 回答