标签: rvalue-reference

函数应该返回RValue Reference是否有原因？技巧,技巧,或成语或模式？

MyClass&& func( ... );

我知道一般返回引用的危险,但有时我们会这样做,不管我们(T& T::operator=(T)只是一个惯用的例子).但是怎么样T&& func(...)？我们会从中获得这样的一般场所吗？与仅仅客户端代码相比,当编写库或API代码时,可能会有所不同？

我猜不是,但我想证实一下.是否有用const Foo&&,Foo哪种类型？

我有一个围绕可移动对象的代理容器类,并希望代理能够隐式地产生对底层对象的rvalue引用,但仅在代理本身被移动时.

我相信我将能够按照提议n2439 "将移动语义扩展到*this"来实现此行为,但它尚未在gcc的发行版中提供,并且暂时不会出现.

下面的代码是我最终的目标,但目前无法实现.在此功能可用之前,是否有任何等效的解决方法？

template< class T >
struct movable_proxy {
    operator T&&() && {
        return std::move(value);
    }

    operator const T&() const& {
        return value;
    }

private:
    T value;
};

我一直在观看Scott Meyers 关于 C++和2012 年之后的Universal References的演讲,到目前为止一切都很有意义.然而,一位观众在大约50分钟后问了一个问题,我也在想.迈尔斯说,他不关心答案,因为它不是惯用的,会愚蠢的想法,但我仍然感兴趣.

提供的代码如下:

// Typical function bodies with overloading:
void doWork(const Widget& param)   // copy
{
  // ops and exprs using param
}
void doWork(Widget&& param)        // move
{
  // ops and exprs using std::move(param)
}

// Typical function implementations with universal reference:
template <typename T>
void doWork(T&& param)             // forward => copy and move
{
  // ops and exprs using std::forward<T>(param)
}

关键是当我们采用右值引用时,我们知道我们有一个右值,所以我们应该std::move保留它是一个右值的事实.当我们采用通用引用(T&&其中T是推导类型)时,我们希望std::forward保留它可能是左值或右值的事实.

所以问题是:既然 …

由于我们在C++中移动了语义,所以现在通常这样做

void set_a(A a) { _a = std::move(a); }

原因是,如果a是左值,则副本将被删除,并且只有一个移动.

但如果a是左值,会发生什么？似乎将有一个复制结构,然后是一个移动赋值(假设A有一个适当的移动赋值运算符).如果对象具有太多成员变量,则移动分配可能成本很高.

另一方面,如果我们这样做

void set_a(const A& a) { _a = a; }

只有一个副本分配.如果我们传递左值,我们可以说这种方式优于传值的习语吗？

鉴于所有这三个函数,这个调用是不明确的.

int f( int );
int f( int && );
int f( int const & );

int q = f( 3 );

删除f( int )导致Clang和GCC更喜欢左值引用而不是左值引用.但是,删除任一引用过载都会导致模糊不清f( int ).

过载分辨率通常是根据严格的部分排序来完成的,但int似乎相当于两个彼此不相等的东西.这里的规则是什么？我似乎记得有关此问题的缺陷报告.

在未来的标准中是否有int &&可能优先考虑int？引用必须绑定到初始化程序,而对象类型不受约束.因此,在我之间超载T并且T &&可以有效地表示"如果我已获得所有权,则使用现有对象,否则复制".(这类似于纯通的价值,但移动节省的开销).由于这些编译器目前的工作,这必须通过重载来完成T const &和T &&,并明确复制.但我甚至不确定这是严格的标准.

例如,stdlibc ++具有以下内容:

unique_lock& operator=(unique_lock&& __u)
{
    if(_M_owns)
        unlock();
    unique_lock(std::move(__u)).swap(*this);
    __u._M_device = 0;
    __u._M_owns = false;
    return *this;
}

为什么不直接将两个__成员分配给*？交换是否意味着__u被分配了*this成员,后来才分配0和false ...在这种情况下交换正在做不必要的工作.我错过了什么？(unique_lock :: swap只对每个成员执行std :: swap)

看来关于C++ 0x的rvalues的主要建议是添加移动构造函数并将运算符移动到类中,直到编译器默认实现它们.

但是如果使用VC10,等待是一种失败的策略,因为自动生成可能不会在VC10 SP1之前,或者在最坏的情况下,VC11.可能,等待这个将是多年来衡量.

这就是我的问题.编写所有这些重复的代码并不好玩.这看起来很不愉快.但对于那些认为很慢的课程来说,这是一个很受欢迎的负担.对于数百个(如果不是数千个)较小的类而言,情况并非如此.

::叹气:: C++ 0x应该让我写更少的代码,而不是更多!

然后我有了一个想法.很多人都愿意共享,我猜.

为什么不按价值传递一切？不会std :: move + copy elision使这几乎达到最佳状态吗？

示例1 - 典型的Pre-0x构造函数

OurClass::OurClass(const SomeClass& obj) : obj(obj) {}

SomeClass o;
OurClass(o);            // single copy
OurClass(std::move(o)); // single copy
OurClass(SomeClass());  // single copy

缺点: rvalues的浪费副本.

例2 - 推荐的C++ 0x？

OurClass::OurClass(const SomeClass& obj) : obj(obj) {}
OurClass::OurClass(SomeClass&& obj) : obj(std::move(obj)) {}

SomeClass o;
OurClass(o);            // single copy
OurClass(std::move(o)); // zero copies, one move
OurClass(SomeClass());  // zero copies, one move

优点:大概是最快的.
缺点:很多代码!

示例3 …

我希望stringstream有一个构造函数窃取其初始内容string&&.STL中通常不存在这样的种间"移动构造函数"吗？如果没有,为什么不呢？

在底部更新

问题1:如何为管理相当繁重的资源的类实现五条规则,但是您希望它按值传递,因为这极大地简化并美化了它的用法？或者甚至不需要所有五项规则？

在实践中,我开始使用3D成像,其中图像通常是128*128*128双倍.能够写这样的东西会让数学变得更容易:

Data a = MakeData();
Data c = 5 * a + ( 1 + MakeMoreData() ) / 3;

问题2:使用复制省略/ RVO /移动语义的组合,编译器应该能够以最少的复制完成此操作,不是吗？

我试图找出如何做到这一点,所以我从基础开始; 假设一个对象实现了实现复制和赋值的传统方式:

class AnObject
{
public:
  AnObject( size_t n = 0 ) :
    n( n ),
    a( new int[ n ] )
  {}
  AnObject( const AnObject& rh ) :
    n( rh.n ),
    a( new int[ rh.n ] )
  {
    std::copy( rh.a, rh.a + n, a );
  }
  AnObject& operator = ( …