c++move语义与右值引用

最新推荐文章于 2024-07-19 18:01:45 发布

xdgs_2005

最新推荐文章于 2024-07-19 18:01:45 发布

阅读量3.8k

点赞数

分类专栏： c/c++

c/c++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏


引言        
    Move语义和右值引用是C++0x加入的最重大语言特性之一。从实践角度讲，它能够完美解决C++中长久以来为人所诟病的临时对象效率问题。从语言本身讲，它健全了C++中的引用类型在左值右值方面的缺陷。从库设计者的角度讲，它给库设计者又带来了一把利器。从库使用者的角度讲，不动一兵一卒便可以获得“免费的”效率提升…
什么是move语义和右值引用
让我们从样例入手，一步步的剖析。我们从持有一块动态分配的内存的简单string类型开始：
 
 
  
  
   
   
    
    
    
    
     
     
      
      
     
     
     
      1 #include <cstring>
 2 #include <algorithm>
 3 
 4 class string
 5 {
 6     char* data;
 7 
 8 public:
 9 
10     string(const char* p)
11     {
12         size_t size = strlen(p) + 1;
13         data = new char[size];
14         memcpy(data, p, size);
15     }
     
     
      
      
     
     
    
    
    
    既然我们要自己管理内存，那我们就应该遵守那三条原则（the rule of three）。
    
     
         
         down vote 
         
         
         The Rule of Three is a rule of thumb for C++, basically saying 
          
          If your class needs any of 
          a copy constructor,
an assignment operator,
or a destructor, 
          defined explictly, then it is likely to need all three of them. 
          
        
    
    我们先来实现复制构造函数和析构函数：
    
    
     
     
      
      
     
     
     
      1     ~string()
 2     {
 3         delete[] data;
 4     }
 5 
 6     string(const string& that)
 7     {
 8         size_t size = strlen(that.data) + 1;
 9         data = new char[size];
10         memcpy(data, that.data, size);
11     }
     
     
      
      
     
     
    
    
    
    复制构造函数定义了怎样复制一个string对象。参数const string& that 可以为想要复制string的以下例子中的任何一种形式：
    
    
     
     1 string a(x);                                    // line 1
2 string b(x + y);                                // line 2
3 string c(some_function_returning_a_string());   // line 3
    
    
    
    我们对上述三行代码进行分析，会发现，只有第一行(line 1)的x深度拷贝是有必要的，因为我们可能会在后边用到x，如果x改变了，我们会很奇怪。你有没有注意到我刚刚把x说了三遍（如果包括这次的话，是四遍），每一遍都是说的同一个对象？我们把x的这种表达式叫做左值(lvalues)。
    
    第二行和第三行的参数就不是左值而是右值，因为表达式产生的string对象是匿名对象，之后没有办法再使用了。右值就是指在下一个分号（更准确的说是在包含右值的完整表达式的最后）销毁的临时对象。这一点非常重要，因为我们可以在b和c的初始化过程中，对源string对象（参数）做任何想要做的事情，并不让用户感觉到。
    
    C++ 11引入了一种新的机制叫做“右值引用”，以便我们通过重载直接使用右值参数。我们所要做的就是写一个以右值引用为参数的构造函数。在这个函数的内部，我们对参数所指向的对象做任何事情，只要我们保持他的合理性：
    
    
     
     1     string(string&& that)   // string&& is an rvalue reference to a string
2     {
3         data = that.data;
4         that.data = 0;
5     }
    
    
    
    我们在这里是怎么做的呢？我们没有深度拷贝堆内存中的数据，而是仅仅复制了指针，并把源对象的指针置空。事实上，我们“偷取”了属于源对象的内存数据。再次，问题的关键变成：无论在任何情况下，都不能让客户觉察到源对象被改变了。在这里，我们并没有真正的复制，所以我们把这个构造函数叫做“转移构造函数”（move constructor, 不知道译法是否确切），他的工作就是把资源从一个对象转移到另一个对象，而不是复制他们。
    
    祝贺你，你现在对move语义有了基础的理解，我们继续来进行赋值操作符的实现。如果你不理解copy and swap惯用法，先去学习 一下，然后再回来，因为这是c++异常安全的一个非常精彩的惯用法。
    
    
     
     
      
      
     
     
     
     1     string& operator=(string that)
2     {
3         std::swap(data, that.data);
4         return *this;
5     }
6 };
     
     
      
      
     
     
    
    
    
    呃，就这些？右值引用在哪里？你可能会这样问。我的答案是：在这里，我们不需要
    
    注意到我们是直接对参数that传值，所以that会像其他任何对象一样被初始化，那么确切的说，that是怎样被初始化的呢？对于C++ 98，答案是复制构造函数，但是对于C++ 11，编译器会依据参数是左值还是右值在复制构造函数和转移构造函数间进行选择。
    
    如果是a=b，这样就会调用复制构造函数来初始化that（因为b是左值），赋值操作符会与新创建的对象交换数据，深度拷贝。这就是copy and swap 惯用法的定义：构造一个副本，与副本交换数据，并让副本在作用域内自动销毁。这里也一样。
    
    如果是a = x + y，这样就会调用转移构造函数来初始化that（因为x+y是右值），所以这里没有深度拷贝，只有高效的数据转移。相对于参数，that依然是一个独立的对象，但是他的构造函数是无用的（trivial），因此堆中的数据没有必要复制，而仅仅是转移。没有必要复制他，因为x+y是右值，再次，从右值指向的对象中转移是没有问题的。
    
    总结一下：复制构造函数执行的是深度拷贝，因为源对象本身必须不能被改变。而转移构造函数却可以复制指针，把源对象的指针置空，这种形式下，这是安全的，因为用户不可能再使用这个对象了。 
    
    在为定义右值引用的系统，如何实现Move语意
    
    右值引用在c++03以后的版本才引入c++语言，而目前很多编译器都是基于c++98标准实现的。那我们是否可以通过自定义的实现来模拟move语意，提升程序的性能呢，答案是肯定的。
    
    我们要利用c++语言自身的几个特性：1) 右值不能绑定到非const的引用 2)c++在初始化变量时可以执行用户自定义的类型转换，详细的可以阅读这篇文章：http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Move_Constructor，利用规则1),我们可以通过定义以非const引用为参数的私有的拷贝构造函数和赋值操作符来禁止左值的拷贝和赋值，然后通过实现自定义的拷贝构造函数和赋值运算符实现右值的拷贝和赋值。

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/compiler_specific.h"

#ifndef BASE_MOVE_H_
#define BASE_MOVE_H_

// Macro with the boilerplate that makes a type move-only in C++03.
//
// USAGE
//
// This macro should be used instead of DISALLOW_COPY_AND_ASSIGN to create
// a "move-only" type.  Unlike DISALLOW_COPY_AND_ASSIGN, this macro should be
// the first line in a class declaration.
//
// A class using this macro must call .Pass() (or somehow be an r-value already)
// before it can be:
//
//   * Passed as a function argument
//   * Used as the right-hand side of an assignment
//   * Returned from a function
//
// Each class will still need to define their own "move constructor" and "move
// operator=" to make this useful.  Here's an example of the macro, the move
// constructor, and the move operator= from the scoped_ptr class:
//
//  template <typename T>
//  class scoped_ptr {
//     MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue)
//   public:
//    scoped_ptr(RValue& other) : ptr_(other.release()) { }
//    scoped_ptr& operator=(RValue& other) {
//      swap(other);
//      return *this;
//    }
//  };
//
// Note that the constructor must NOT be marked explicit.
//
// For consistency, the second parameter to the macro should always be RValue
// unless you have a strong reason to do otherwise.  It is only exposed as a
// macro parameter so that the move constructor and move operator= don't look
// like they're using a phantom type.
//
//
// HOW THIS WORKS
//
// For a thorough explanation of this technique, see:
//
//   http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Move_Constructor
//
// The summary is that we take advantage of 2 properties:
//
//   1) non-const references will not bind to r-values.
//   2) C++ can apply one user-defined conversion when initializing a
//      variable.
//
// The first lets us disable the copy constructor and assignment operator
// by declaring private version of them with a non-const reference parameter.
//
// For l-values, direct initialization still fails like in
// DISALLOW_COPY_AND_ASSIGN because the copy constructor and assignment
// operators are private.
//
// For r-values, the situation is different. The copy constructor and
// assignment operator are not viable due to (1), so we are trying to call
// a non-existent constructor and non-existing operator= rather than a private
// one.  Since we have not committed an error quite yet, we can provide an
// alternate conversion sequence and a constructor.  We add
//
//   * a private struct named "RValue"
//   * a user-defined conversion "operator RValue()"
//   * a "move constructor" and "move operator=" that take the RValue& as
//     their sole parameter.
//
// Only r-values will trigger this sequence and execute our "move constructor"
// or "move operator=."  L-values will match the private copy constructor and
// operator= first giving a "private in this context" error.  This combination
// gives us a move-only type.
//
// For signaling a destructive transfer of data from an l-value, we provide a
// method named Pass() which creates an r-value for the current instance
// triggering the move constructor or move operator=.
//
// Other ways to get r-values is to use the result of an expression like a
// function call.
//
// Here's an example with comments explaining what gets triggered where:
//
//    class Foo {
//      MOVE_ONLY_TYPE_FOR_CPP_03(Foo, RValue);
//
//     public:
//       ... API ...
//       Foo(RValue other);           // Move constructor.
//       Foo& operator=(RValue rhs);  // Move operator=
//    };
//
//    Foo MakeFoo();  // Function that returns a Foo.
//
//    Foo f;
//    Foo f_copy(f);  // ERROR: Foo(Foo&) is private in this context.
//    Foo f_assign;
//    f_assign = f;   // ERROR: operator=(Foo&) is private in this context.
//
//
//    Foo f(MakeFoo());      // R-value so alternate conversion executed.
//    Foo f_copy(f.Pass());  // R-value so alternate conversion executed.
//    f = f_copy.Pass();     // R-value so alternate conversion executed.
//
//
// IMPLEMENTATION SUBTLETIES WITH RValue
//
// The RValue struct is just a container for a pointer back to the original
// object. It should only ever be created as a temporary, and no external
// class should ever declare it or use it in a parameter.
//
// It is tempting to want to use the RValue type in function parameters, but
// excluding the limited usage here for the move constructor and move
// operator=, doing so would mean that the function could take both r-values
// and l-values equially which is unexpected.  See COMPARED To Boost.Move for
// more details.
//
// An alternate, and incorrect, implementation of the RValue class used by
// Boost.Move makes RValue a fieldless child of the move-only type. RValue&
// is then used in place of RValue in the various operators.  The RValue& is
// "created" by doing *reinterpret_cast<RValue*>(this).  This has the appeal
// of never creating a temporary RValue struct even with optimizations
// disabled.  Also, by virtue of inheritance you can treat the RValue
// reference as if it were the move-only type itself.  Unfortunately,
// using the result of this reinterpret_cast<> is actually undefined behavior
// due to C++98 5.2.10.7. In certain compilers (e.g., NaCl) the optimizer
// will generate non-working code.
//
// In optimized builds, both implementations generate the same assembly so we
// choose the one that adheres to the standard.
//
//
// WHY HAVE typedef void MoveOnlyTypeForCPP03
//
// Callback<>/Bind() needs to understand movable-but-not-copyable semantics
// to call .Pass() appropriately when it is expected to transfer the value.
// The cryptic typedef MoveOnlyTypeForCPP03 is added to make this check
// easy and automatic in helper templates for Callback<>/Bind().
// See IsMoveOnlyType template and its usage in base/callback_internal.h
// for more details.
//
//
// COMPARED TO C++11
//
// In C++11, you would implement this functionality using an r-value reference
// and our .Pass() method would be replaced with a call to std::move().
//
// This emulation also has a deficiency where it uses up the single
// user-defined conversion allowed by C++ during initialization.  This can
// cause problems in some API edge cases.  For instance, in scoped_ptr, it is
// impossible to make a function "void Foo(scoped_ptr<Parent> p)" accept a
// value of type scoped_ptr<Child> even if you add a constructor to
// scoped_ptr<> that would make it look like it should work.  C++11 does not
// have this deficiency.
//
//
// COMPARED TO Boost.Move
//
// Our implementation similar to Boost.Move, but we keep the RValue struct
// private to the move-only type, and we don't use the reinterpret_cast<> hack.
//
// In Boost.Move, RValue is the boost::rv<> template.  This type can be used
// when writing APIs like:
//
//   void MyFunc(boost::rv<Foo>& f)
//
// that can take advantage of rv<> to avoid extra copies of a type.  However you
// would still be able to call this version of MyFunc with an l-value:
//
//   Foo f;
//   MyFunc(f);  // Uh oh, we probably just destroyed |f| w/o calling Pass().
//
// unless someone is very careful to also declare a parallel override like:
//
//   void MyFunc(const Foo& f)
//
// that would catch the l-values first.  This was declared unsafe in C++11 and
// a C++11 compiler will explicitly fail MyFunc(f).  Unfortunately, we cannot
// ensure this in C++03.
//
// Since we have no need for writing such APIs yet, our implementation keeps
// RValue private and uses a .Pass() method to do the conversion instead of
// trying to write a version of "std::move()." Writing an API like std::move()
// would require the RValue struct to be public.
//
//
// CAVEATS
//
// If you include a move-only type as a field inside a class that does not
// explicitly declare a copy constructor, the containing class's implicit
// copy constructor will change from Containing(const Containing&) to
// Containing(Containing&).  This can cause some unexpected errors.
//
//   http://llvm.org/bugs/show_bug.cgi?id=11528
//
// The workaround is to explicitly declare your copy constructor.
//
#define MOVE_ONLY_TYPE_FOR_CPP_03(type, rvalue_type) \
 private: \
  struct rvalue_type { \
    explicit rvalue_type(type* object) : object(object) {} \
    type* object; \
  }; \
  type(type&); \
  void operator=(type&); \
 public: \
  operator rvalue_type() { return rvalue_type(this); } \
  type Pass() WARN_UNUSED_RESULT { return type(rvalue_type(this)); } \
  typedef void MoveOnlyTypeForCPP03; \
 private:

#define MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(type) \
 private: \
  type(type&); \
  void operator=(type&); \
 public: \
  type&& Pass() WARN_UNUSED_RESULT { return static_cast<type&&>(*this); } \
  typedef void MoveOnlyTypeForCPP03; \
 private:

#endif  // BASE_MOVE_H_

参考地址：http://www.cnblogs.com/tingshuo/archive/2013/01/21/2870035.html

down vote

The Rule of Three is a rule of thumb for C++, basically saying

If your class needs any of

a copy constructor,
an assignment operator,
or a destructor,

defined explictly, then it is likely to need all three of them.