C++11新特性之 Move semantics(移动语义)

最新推荐文章于 2024-05-12 09:30:00 发布
最新推荐文章于 2024-05-12 09:30:00 发布
阅读量262 收藏
点赞数
分类专栏： C++

来源： https://blog.csdn.net/wangshubo1989/article/details/49748703

按值传递的意义是什么？ 
当一个函数的参数按值传递时，这就会进行拷贝。当然，编译器懂得如何去拷贝。 
而对于我们自定义的类型，我们也许需要提供拷贝构造函数。

但是不得不说，拷贝的代价是昂贵的。

所以我们需要寻找一个避免不必要拷贝的方法，即C++11提供的移动语义。 
上一篇博客中有一个句话用到了：

#include <iostream>

void f(int& i) { std::cout << "lvalue ref: " << i << "\n"; }
void f(int&& i) { std::cout << "rvalue ref: " << i << "\n"; }

int main()
{
    int i = 77;
    f(i);    // lvalue ref called
    f(99);   // rvalue ref called

    f(std::move(i));  // 稍后介绍

    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

实际上，右值引用注意用于创建移动构造函数和移动赋值运算。

移动构造函数类似于拷贝构造函数，把类的实例对象作为参数，并创建一个新的实例对象。 
但是 移动构造函数可以避免内存的重新分配，因为我们知道右值引用提供了一个暂时的对象，而不是进行copy，所以我们可以进行移动。

换言之，在设计到关于临时对象时，右值引用和移动语义允许我们避免不必要的拷贝。我们不想拷贝将要消失的临时对象，所以这个临时对象的资源可以被我们用作于其他的对象。

右值就是典型的临时变量，并且他们可以被修改。如果我们知道一个函数的参数是一个右值，我们可以把它当做一个临时存储。这就意味着我们要移动而不是拷贝右值参数的内容。这就会节省很多的空间。

说多无语，看代码：

#include <iostream>
#include <algorithm>

class A
{
public:

    // Simple constructor that initializes the resource.
    explicit A(size_t length)
        : mLength(length), mData(new int[length])
    {
        std::cout << "A(size_t). length = "
        << mLength << "." << std::endl;
    }

    // Destructor.
    ~A()
    {
    std::cout << "~A(). length = " << mLength << ".";

    if (mData != NULL) {
            std::cout << " Deleting resource.";
        delete[] mData;  // Delete the resource.
    }

    std::cout << std::endl;
    }

    // Copy constructor.
    A(const A& other)
        : mLength(other.mLength), mData(new int[other.mLength])
    {
    std::cout << "A(const A&). length = "
        << other.mLength << ". Copying resource." << std::endl;

    std::copy(other.mData, other.mData + mLength, mData);
    }

    // Copy assignment operator.
    A& operator=(const A& other)
    {
    std::cout << "operator=(const A&). length = "
             << other.mLength << ". Copying resource." << std::endl;

    if (this != &other) {
        delete[] mData;  // Free the existing resource.
        mLength = other.mLength;
            mData = new int[mLength];
            std::copy(other.mData, other.mData + mLength, mData);
    }
    return *this;
    }

    // Move constructor.
    A(A&& other) : mData(NULL), mLength(0)
    {
        std::cout << "A(A&&). length = " 
             << other.mLength << ". Moving resource.\n";

        // Copy the data pointer and its length from the 
        // source object.
        mData = other.mData;
        mLength = other.mLength;

        // Release the data pointer from the source object so that
        // the destructor does not free the memory multiple times.
        other.mData = NULL;
        other.mLength = 0;
    }

    // Move assignment operator.
    A& operator=(A&& other)
    {
        std::cout << "operator=(A&&). length = " 
             << other.mLength << "." << std::endl;

        if (this != &other) {
          // Free the existing resource.
          delete[] mData;

          // Copy the data pointer and its length from the 
          // source object.
          mData = other.mData;
          mLength = other.mLength;

          // Release the data pointer from the source object so that
          // the destructor does not free the memory multiple times.
          other.mData = NULL;
          other.mLength = 0;
       }
       return *this;
    }

    // Retrieves the length of the data resource.
    size_t Length() const
    {
        return mLength;
    }

private:
    size_t mLength; // The length of the resource.
    int* mData;     // The resource.
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103

移动构造函数 
语法：

A(A&& other) noexcept    // C++11 - specifying non-exception throwing functions
{
  mData =  other.mData;  // shallow copy or referential copy
  other.mData = nullptr;
}
  • 1
  • 2
  • 3
  • 4
  • 5

最主要的是没有用到新的资源，是移动而不是拷贝。 
假设一个地址指向了一个有一百万个int元素的数组，使用move构造函数，我们没有创造什么，所以代价很低。

// Move constructor.
A(A&& other) : mData(NULL), mLength(0)
{
    // Copy the data pointer and its length from the 
    // source object.
    mData = other.mData;
    mLength = other.mLength;

    // Release the data pointer from the source object so that
    // the destructor does not free the memory multiple times.
    other.mData = NULL;
    other.mLength = 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

移动比拷贝更快！！！

移动赋值运算符 
语法：

A& operator=(A&& other) noexcept
{
  mData =  other.mData;
  other.mData = nullptr;
  return *this;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

工作流程这样的：Google上这么说的：

Release any resources that *this currently owns. 
Pilfer other’s resource. 
Set other to a default state. 
Return *this.

// Move assignment operator.
A& operator=(A&& other)
{
    std::cout << "operator=(A&&). length = " 
             << other.mLength << "." << std::endl;

    if (this != &other) {
      // Free the existing resource.
      delete[] mData;

      // Copy the data pointer and its length from the 
      // source object.
      mData = other.mData;
      mLength = other.mLength;

      // Release the data pointer from the source object so that
      // the destructor does not free the memory multiple times.
      other.mData = NULL;
      other.mLength = 0;
   }
   return *this;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

让我们看几个move带来的好处吧！ 
vector众所周知，C++11后对vector也进行了一些优化。例如vector::push_back()被定义为了两种版本的重载，一个是cosnt T&左值作为参数，一个是T&&右值作为参数。例如下面的代码：

std::vector<A> v;
v.push_back(A(25));
v.push_back(A(75));
  • 1
  • 2
  • 3

上面两个push_back()都会调用push_back(T&&)版本，因为他们的参数为右值。这样提高了效率。

而 当参数为左值的时候，会调用push_back(const T&) 。

#include <vector>

int main()
{
    std::vector<A> v;
    A aObj(25);       // lvalue
    v.push_back(aObj);  // push_back(const T&)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

但事实我们可以使用 static_cast进行强制：

// calls push_back(T&&)
v.push_back(static_cast<A&&>(aObj));
  • 1
  • 2

我们可以使用std::move完成上面的任务：

v.push_back(std::move(aObj));  //calls push_back(T&&)
  • 1

似乎push_back(T&&)永远是最佳选择，但是一定要记住： 
push_back(T&&) 使得参数为空。如果我们想要保留参数的值，我们这个时候需要使用拷贝，而不是移动。

最后写一个例子，看看如何使用move来交换两个对象：

#include <iostream>
using namespace std;

class A
{
  public:
    // constructor
    explicit A(size_t length)
        : mLength(length), mData(new int[length]) {}

    // move constructor
    A(A&& other)
    {
      mData = other.mData;
      mLength = other.mLength;
      other.mData = nullptr;
      other.mLength = 0;
    }

    // move assignment
    A& operator=(A&& other) noexcept
    {
      mData =  other.mData;
      mLength = other.mLength;
      other.mData = nullptr;
      other.mLength = 0;
      return *this;
    }

    size_t getLength() { return mLength; }


    void swap(A& other)
    {
      A temp = move(other);
      other = move(*this);
      *this = move(temp);
    }

    int* get_mData() { return mData; }

  private:
    int *mData;
    size_t mLength;
};

int main()
{
  A a(11), b(22);
  cout << a.getLength() << ' ' << b.getLength() << endl;
  cout << a.get_mData() << ' ' << b.get_mData() << endl;
  swap(a,b);
  cout << a.getLength() << ' ' << b.getLength() << endl;
  cout << a.get_mData() << ' ' << b.get_mData() << endl;
  return 0;
}
kkkmmmjjjj
关注
专栏目录
C++11中value category（值类别）及move semantics（移动语义）的介绍
08-27
C++11引入了value category（值类别）和move semantics（移动语义）的概念，以增强语言的效率和性能。值类别是对表达式在程序执行过程中所处状态的分类，而移动语义则是一种优化机制，它允许资源的有效转移，避免...
C++11 Move semantics （移动语义）
heary29的专栏
10-22 1065
C++11加入了右值引用(value reference)的概念（用&&标识），用来区分对左值和右值的引用。左值就是一个有名字的对象，而右值则是一个无名对象（临时对象）。move语义允许修改右值（以前右值被看作是不可修改的，等同于const T&类型）。c++11中所有的值必须是左值、右值、将亡值之一。 即：在使用右值引用的时候，因为右值是一个无名的临时对象，对于对象的移...
[C++11] Move Semantics
seemuch的专栏
01-31 1190
1. lvalue和rvalue 一切都要从两个古老的概念开始讲起：lvalue和rvalue。先看一段代码： int a = 3; 6 = a; 这段代码一看就是有问题的，而且显然问题出在了第二行。那么问题到底是什么呢？答案就是：6是一个rvalue，我们不能把rvalue放在赋值操作的左边。这样看来，lvalue和rvalue的意思就呼之欲出了：lvalue是可以放在赋值操作左边的；而r
Move semantics(C++11)
tt33415366的专栏
08-04 714
/*  * Compile with:   *       g++ move_test.c -o move_test -std=c++11 -g -fno-elide-constructors  * -fno-elide-constructors disabled the return value optimize.  */ #include #include class
C++11：移动语义
you_fathe的博客
08-04 611
C++11：移动语义的总结
C++11新特性解析与应用_C++11新特性_
09-29
这些只是C++11新特性的一小部分，还有像`decltype`、`noexcept`、`constexpr`、`move semantics`等其他重要特性。理解和掌握这些新特性，可以让你的C++代码更高效、更安全，同时也更易于维护和理解。在实际项目中，...
C++11新特性解析与应用_扫描版本
09-06
- 右值引用 (`&&`) 用于区分左值和右值，增强了对临时对象的处理能力，使得移动语义（Move Semantics）成为可能，从而提高了性能。 3. **lambda表达式**： - Lambda 表达式提供了一种内联定义匿名函数的方式，...
C++ move semantics
keineahnung2345的博客
01-23 471
C++11中引入了move semantics，它是基於rvalue reference來優化物件搬移效率的一種機制。 在一個自定義的類別中，如果我們希望使用move semantics，就必須為它定義兩個成員函數：move constructor及move assignment operator。
C++11中移动语义(std::move)和完美转发(std::forward)
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
09-26 8208
前言所有的手段都是为了解决已存在的问题。std::move和std::forward是C++11中的特性，是为了解决C++98/C++0x中遗留的问题，虽从理解上来看比较复杂，却是较好的解决手段。左值(lvalue)与右值(rvalue)左值与右值的概念其实在C++0x中就有了。概括的讲，凡是能够取地址的可以称之为左值，反之称之为右值，C++中并没有对左值和右值给出明确的定义，从其解决手段来看类似上
C++11-移动语义
xiaoqiang321的专栏
07-19 318
介绍了C++11移动语义,以及编译器的默认优化, string copy-on-write机制
c++11移动语义
qq_36865682的博客
04-20 340
C++11移动语义特性 移动语义的必要性 C++11中将数据分为左值和右值。左值为分配内存地址存储在内存中的值。右值为存储在寄存器中但不分配内存地址的值。所以左值可以取地址而右值不可以取地址。 对于右值对象来说，想要将右值对象存放在容器或数组中会发生：根据右值构造新左值对象->销毁右值对象->将新产生的左值对象存放到容器中。为了简化这个过程的时间空间开销引进移动语义。 移动语义特性 移动语义是指将临时的右值对象构造一个新的左值对象，并且该左值对象不占用新的内存空间。 移动构造函数和移
C++ 11的移动语义
xu_fu_yong的专栏
02-10 355
C++ 11的移动语义
C++11中的移动语义
m0_71009069的博客
01-25 1048
C++11中的移动语义
C++ 11中的移动语义
mo4776的博客
09-15 389
移动语义 文章目录移动语义拷贝与移动拷贝移动左值与右值左值引用和右值引用移动语义移动构造函数和移动赋值函数移动对象后为可析构状态编译器生成移动操作移动操作的匹配std::move函数STL中的移动语义 拷贝与移动 一个形象的比喻 如何把一个冰箱里的大象放到另一个冰箱中?打开冰箱1的门，打开冰箱2的门，将冰箱1里的大象移动冰箱2中，关上冰箱门。 这是一个很自然的方法，那么还有一种方法，将冰箱2里的大象复制一头，将复制的大象放到冰箱1中，再让冰箱2里的大象消失掉。这种方法是不是感觉似曾相识，这个就是C ++
c++ move semantics
sinat_26930073的博客
03-19 245
https://www.youtube.com/watch?v=cO1lb2MiDr8
C++11移动语义解析
Nemo的博客
03-14 1795
C++11移动语义解读
C++11 移动语义 (move semantics)
weixin_51796629的博客
09-28 106
把这段代码粘贴到自己的编译器中, 开启单步调试, 重点关注string和dest这两个对象下面的m_Data内存地址的变化。你就能了解到,为什么这么多人说,移动语义本质上就是"偷"了.
C++11 新特性：移动语义
最新发布
kelvin_yin的专栏
05-12 1043
C++11 引入的移动语义是对 C++ 语言的一大改进，它提供了一种更有效的资源管理方式，特别是在处理大量数据或资源密集型对象时。移动语义通过引入右值引用（Right-Value Reference，标记为&&）和两个新的构造函数——移动构造函数（Move Constructor）和移动赋值运算符（Move Assignment Operator）——来实现。这些新特性允许开发者优化程序性能，减少不必要的对象拷贝，从而提高效率。
C++11新特性：深入理解右值引用与移动语义
C++11引入了右值引用（Rvalue Reference）这一重要特性，这在很大程度上解决了C++98中的两个关键问题：移动语义（Move Semantics）和完美转发（Perfect Forwarding）。这些概念虽然复杂，但对于理解和优化C++程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值