转自: https://www.cnblogs.com/guxuanqing/p/6594857.html#:~:text=%20%E5%8F%B3%E5%80%BC%E5%BC%95%E7%94%A8%E6%98%AF%E7%94%A8%E6%9D%A5%E6%94%AF%E6%8C%81%E8%BD%AC%E7%A7%BB%E8%AF%AD%E4%B9%89%E7%9A%84%E3%80%82%20%E8%BD%AC%E7%A7%BB%E8%AF%AD%E4%B9%89%E5%8F%AF%E4%BB%A5%E5%B0%86%E8%B5%84%E6%BA%90%20%28%20%E5%A0%86%EF%BC%8C%E7%B3%BB%E7%BB%9F%E5%AF%B9%E8%B1%A1%E7%AD%89%20%29%20%E4%BB%8E%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%E8%BD%AC%E7%A7%BB%E5%88%B0%E5%8F%A6%E4%B8%80%E4%B8%AA%E5%AF%B9%E8%B1%A1%EF%BC%8C%E8%BF%99%E6%A0%B7%E8%83%BD%E5%A4%9F%E5%87%8F%E5%B0%91%E4%B8%8D%E5%BF%85%E8%A6%81%E7%9A%84%E4%B8%B4%E6%97%B6%E5%AF%B9%E8%B1%A1%E7%9A%84%E5%88%9B%E5%BB%BA%E3%80%81%E6%8B%B7%E8%B4%9D%E4%BB%A5%E5%8F%8A%E9%94%80%E6%AF%81%EF%BC%8C%E8%83%BD%E5%A4%9F%E5%A4%A7%E5%B9%85%E5%BA%A6%E6%8F%90%E9%AB%98%20C%2B%2B,%E5%AF%B9%E6%80%A7%E8%83%BD%E6%9C%89%E4%B8%A5%E9%87%8D%E5%BD%B1%E5%93%8D%E3%80%82%20%E8%BD%AC%E7%A7%BB%E8%AF%AD%E4%B9%89%E6%98%AF%E5%92%8C%E6%8B%B7%E8%B4%9D%E8%AF%AD%E4%B9%89%E7%9B%B8%E5%AF%B9%E7%9A%84%EF%BC%8C%E5%8F%AF%E4%BB%A5%E7%B1%BB%E6%AF%94%E6%96%87%E4%BB%B6%E7%9A%84%E5%89%AA%E5%88%87%E4%B8%8E%E6%8B%B7%E8%B4%9D%EF%BC%8C%E5%BD%93%E6%88%91%E4%BB%AC%E5%B0%86%E6%96%87%E4%BB%B6%E4%BB%8E%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E6%8B%B7%E8%B4%9D%E5%88%B0%E5%8F%A6%E4%B8%80%E4%B8%AA%E7%9B%AE%E5%BD%95%E6%97%B6%EF%BC%8C%E9%80%9F%E5%BA%A6%E6%AF%94%E5%89%AA%E5%88%87%E6%85%A2%E5%BE%88%E5%A4%9A%E3%80%82%20%E9%80%9A%E8%BF%87%E8%BD%AC%E7%A7%BB%E8%AF%AD%E4%B9%89%EF%BC%8C%E4%B8%B4%E6%97%B6%E5%AF%B9%E8%B1%A1%E4%B8%AD%E7%9A%84%E8%B5%84%E6%BA%90%E8%83%BD%E5%A4%9F%E8%BD%AC%E7%A7%BB%E5%85%B6%E5%AE%83%E7%9A%84%E5%AF%B9%E8%B1%A1%E9%87%8C%E3%80%82%20%E5%9C%A8%E7%8E%B0%E6%9C%89%E7%9A%84%20C%2B%2B%20%E6%9C%BA%E5%88%B6%E4%B8%AD%EF%BC%8C%E6%88%91%E4%BB%AC%E5%8F%AF%E4%BB%A5%E5%AE%9A%E4%B9%89%E6%8B%B7%E8%B4%9D%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E5%92%8C%E8%B5%8B%E5%80%BC%E5%87%BD%E6%95%B0%E3%80%82%20%E8%A6%81%E5%AE%9E%E7%8E%B0%E8%BD%AC%E7%A7%BB%E8%AF%AD%E4%B9%89%EF%BC%8C%E9%9C%80%E8%A6%81%E5%AE%9A%E4%B9%89%E8%BD%AC%E7%A7%BB%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%EF%BC%8C%E8%BF%98%E5%8F%AF%E4%BB%A5%E5%AE%9A%E4%B9%89%E8%BD%AC%E7%A7%BB%E8%B5%8B%E5%80%BC%E6%93%8D%E4%BD%9C%E7%AC%A6%E3%80%82%20%E5%AF%B9%E4%BA%8E%E5%8F%B3%E5%80%BC%E7%9A%84%E6%8B%B7%E8%B4%9D%E5%92%8C%E8%B5%8B%E5%80%BC%E4%BC%9A%E8%B0%83%E7%94%A8%E8%BD%AC%E7%A7%BB%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E5%92%8C%E8%BD%AC%E7%A7%BB%E8%B5%8B%E5%80%BC%E6%93%8D%E4%BD%9C%E7%AC%A6%E3%80%82

阅读目录

  • 关于左值和右值的定义
  • 转移语义以及转移构造函数和转移复制运算符
右值引用是解决语义支持提出的

https://blog.csdn.net/xiaolewennofollow/article/details/52559306
这篇文章要介绍的内容和标题一致,关于C++ 11中的这几个特性网上介绍的文章很多,看了一些之后想把几个比较关键的点总结记录一下,文章比较长。给出了很多代码示例,都是编译运行测试过的,希望能用这些帮助理解C++ 11中这些比较重要的特性。

关于左值和右值的定义

左值和右值在C中就存在,不过存在感不高,在C++尤其是C++11中这两个概念比较重要,左值就是有名字的变量(对象),可以被赋值,可以在多条语句中使用,而右值呢,就是临时变量(对象),没有名字,只能在一条语句中出现,不能被赋值。

在 C++11 之前,右值是不能被引用的,最大限度就是用常量引用绑定一个右值,如 :

const int& i = 3;

在这种情况下,右值不能被修改的。但是实际上右值是可以被修改的,如 :

T().set().get();

T 是一个类,set 是一个函数为 T 中的一个变量赋值,get 用来取出这个变量的值。在这句中,T() 生成一个临时对象,就是右值,set() 修改了变量的值,也就修改了这个右值。 既然右值可以被修改,那么就可以实现右值引用。右值引用能够方便地解决实际工程中的问题,实现非常有吸引力的解决方案。

右值引用

左值的声明符号为”&”, 为了和左值区分,右值的声明符号为”&&”。

给出一个实例程序如下

#include <iostream>

void process_value(int& i) 
{ 
  std::cout << "LValue processed: " << i << std::endl; 
} 

void process_value(int&& i) 
{ 
  std::cout << "RValue processed: " << i << std::endl; 
} 

int main() 
{ 
  int a = 0; 
  process_value(a);
  process_value(1); 
}

结果如下

wxl@dev:~$ g++ -std=c++11  test.cpp
wxl@dev:~$ ./a.out 
LValue processed: 0
RValue processed: 1
Process_value 函数被重载,分别接受左值和右值。由输出结果可以看出,临时对象是作为右值处理的。

下面涉及到一个问题: x的类型是右值引用,指向一个右值,但x本身是左值还是右值呢?C++11对此做出了区分:

Things that are declared as rvalue reference can be lvalues or rvalues. The distinguishing criterion is: if it has a name, then it is an lvalue. Otherwise, it is an rvalue.

对上面的程序稍作修改就可以印证这个说法

#include <iostream>

void process_value(int& i) 
{ 
  std::cout << "LValue processed: " << i << std::endl; 
} 

void process_value(int&& i) 
{ 
  std::cout << "RValue processed: "  << std::endl; 
} 

int main() 
{ 
  int a = 0; 
  process_value(a);
  int&& x = 3;
  process_value(x); 
}
wxl@dev:~$ g++ -std=c++11  test.cpp
wxl@dev:~$ ./a.out 
LValue processed: 0
LValue processed: 3

x 是一个右值引用,指向一个右值3,但是由于x是有名字的,所以x在这里被视为一个左值,所以在函数重载的时候选择为第一个函数。

右值引用的意义

直观意义:为临时变量续命,也就是为右值续命,因为右值在表达式结束后就消亡了,如果想继续使用右值,那就会动用昂贵的拷贝构造函数。(关于这部分,推荐一本书《深入理解C++11》) 右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆,系统对象等 ) 从一个对象转移到另一个对象,这样能够减少不必要的临时对象的创建、拷贝以及销毁,能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。 转移语义是和拷贝语义相对的,可以类比文件的剪切与拷贝,当我们将文件从一个目录拷贝到另一个目录时,速度比剪切慢很多。 通过转移语义,临时对象中的资源能够转移其它的对象里。 在现有的 C++ 机制中,我们可以定义拷贝构造函数和赋值函数。要实现转移语义,需要定义转移构造函数,还可以定义转移赋值操作符。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。如果转移构造函数和转移拷贝操作符没有定义,那么就遵循现有的机制,拷贝构造函数和赋值操作符会被调用。 普通的函数和操作符也可以利用右值引用操作符实现转移语义。

转移语义以及转移构造函数和转移复制运算符

以一个简单的 string 类为示例,实现拷贝构造函数和拷贝赋值操作符。

 class MyString { 
 private: 
  char* _data; 
  size_t   _len; 
  void _init_data(const char *s) { 
    _data = new char[_len+1]; 
    memcpy(_data, s, _len); 
    _data[_len] = '\0'; 
  } 
 public: 
  MyString() { 
    _data = NULL; 
    _len = 0; 
  } 

  MyString(const char* p) { 
    _len = strlen (p); 
    _init_data(p); 
  } 

  MyString(const MyString& str) { 
    _len = str._len; 
    _init_data(str._data); 
    std::cout << "Copy Constructor is called! source: " << str._data << std::endl; 
  } 

  MyString& operator=(const MyString& str) { 
    if (this != &str) { 
      _len = str._len; 
      _init_data(str._data); 
    } 
    std::cout << "Copy Assignment is called! source: " << str._data << std::endl; 
    return *this; 
  } 

  virtual ~MyString() { 
    if (_data) free(_data); 
  } 
 }; 

 int main() { 
  MyString a; 
  a = MyString("Hello"); 
  std::vector<MyString> vec; 
  vec.push_back(MyString("World")); 
 }
 Copy Assignment is called! source: Hello 
 Copy Constructor is called! source: World

这个 string 类已经基本满足我们演示的需要。在 main 函数中,实现了调用拷贝构造函数的操作和拷贝赋值操作符的操作。MyString(“Hello”) 和 MyString(“World”) 都是临时对象,也就是右值。虽然它们是临时的,但程序仍然调用了拷贝构造和拷贝赋值,造成了没有意义的资源申请和释放的操作。如果能够直接使用临时对象已经申请的资源,既能节省资源,有能节省资源申请和释放的时间。这正是定义转移语义的目的。

我们先定义转移构造函数。

  MyString(MyString&& str) { 
    std::cout << "Move Constructor is called! source: " << str._data << std::endl; 
    _len = str._len; 
    _data = str._data; 
    str._len = 0; 
    str._data = NULL; 
 }

有下面几点需要对照代码注意:

  1. 参数(右值)的符号必须是右值引用符号,即“&&”。
  2. 参数(右值)不可以是常量,因为我们需要修改右值。
  3. 参数(右值)的资源链接和标记必须修改。否则,右值的析构函数就会释放资源。转移到新对象的资源也就无效了。

现在我们定义转移赋值操作符。

  MyString& operator=(MyString&& str) { 
    std::cout << "Move Assignment is called! source: " << str._data << std::endl; 
    if (this != &str) { 
      _len = str._len; 
      _data = str._data; 
      str._len = 0; 
      str._data = NULL; 
    } 
    return *this; 
 }

这里需要注意的问题和转移构造函数是一样的。 增加了转移构造函数和转移复制操作符后,我们的程序运行结果为 :

由此看出,编译器区分了左值和右值,对右值调用了转移构造函数和转移赋值操作符。节省了资源,提高了程序运行的效率。 有了右值引用和转移语义,我们在设计和实现类时,对于需要动态申请大量资源的类,应该设计转移构造函数和转移赋值函数,以提高应用程序的效率。

关于std::move()和std::forward 再次推荐一本书:《effective modern C++》 英文版的,这里有篇关于其中item25的翻译不错

请看这里 https://blog.csdn.net/coolmeme/article/details/44459999

但是这几点总结的不错

  1. std::move执行一个无条件的转化到右值。它本身并不移动任何东西;

  2. std::forward把其参数转换为右值,仅仅在那个参数被绑定到一个右值时;

  3. std::move和std::forward在运行时(runtime)都不做任何事。

/*
 * MS.cpp
 *
 *  Created on: 2020年10月28日
 *      Author: xor
 */

#include <iostream>
#include <string.h>

#include <utility>

class MS {
private:
    char* _data;
    size_t   _len;
    void _init_data(const char *s) {
        _data = new char[_len+1];
        memcpy(_data, s, _len);
        _data[_len] = '\0';
    }
public:
    MS() {
        _data = NULL;
        _len = 0;
    }

    MS(const char *str)
    {
        if(str)
        {
            _len = strlen(str)+1;
            _data = new char[strlen(str)+1];
            memcpy(_data, str, _len);
        }
        else
        {
            _data = new char[1];
            _data[0] = '\0';
        }
    }

    MS(MS &&ms)
    {
        _data = ms._data;
        _len = ms._len;

        ms._data = NULL;
        ms._len = 0;
        std::cout <<  _data << " lc " << _len << std::endl;
    }

    MS &operator=(MS &&ms);

};

MS &MS::operator =(MS &&ms)
{
    if(this != &ms)
    {
        _data = ms._data;
        _len = ms._len;

        ms._data = NULL;
        ms._len = 0;
    }
    std::cout << _data << " lop " << _len << std::endl;
    return *this;
}

int main()
{
    MS &&ms = MS("hik");
    MS ms1(std::forward<MS>(ms));

    return 0;
}

标签: C++

添加新评论