C++新特性：右值引用，移动语义，完美转发

int a = 6;

struct A {
  A(int a = 0) {
    a_ = a;
 }
  int a_;
};
A a = A();

int a = 5;
int &ref_a = a; // 左值引用指向左值，编译通过
int &ref_a = 5; // 左值引用指向了右值，会编译失败

const int &ref_a = 5;  // 编译通过

void push_back (const value_type& val);

int &&ref_a_right = 5; // ok
int a = 5;
int &&ref_a_left = a; // 编译不过，右值引用不可以指向左值
ref_a_right = 6; // 右值引用的用途：可以修改右值

int a = 5; // a是个左值
int &ref_a_left = a; // 左值引用指向左值
int &&ref_a_right = std::move(a); // 通过std::move将左值转化为右值，可以被右值引用指向
cout << a; // 打印结果：5

int &&ref_a = 5;
ref_a = 6;
等同于以下代码：
int temp = 5;
int &&ref_a = std::move(temp);
ref_a = 6;
// 此时temp等于6，ref_a 是temp的引用

// 形参是个右值引用
void change(int&& right_value) {
  right_value = 8;
}
int main() {
  int a = 5; // a是个左值
  int &ref_a_left = a; // ref_a_left是个左值引用
  int &&ref_a_right = std::move(a); // ref_a_right是个右值引用
  change(a); // 编译不过，a是左值，change参数要求右值
  change(ref_a_left); // 编译不过，左值引用ref_a_left本身也是个左值
  change(ref_a_right); // 编译不过，右值引用ref_a_right本身也是个左值
  change(std::move(a)); // 编译通过
  change(std::move(ref_a_right)); // 编译通过
  change(std::move(ref_a_left)); // 编译通过
  change(5); // 当然可以直接接右值，编译通过
  cout << &a << ' ';
  cout << &ref_a_left << ' ';
  cout << &ref_a_right;
  // 打印这三个左值的地址，都是一样的
}

#include <iostream>
using namespace std;
class A
{
public:
  A() :m_ptr(new int(0)) {
    cout << "constructor A"  << endl;
 }
  ~A(){
    cout << "destructor A, m_ptr:" << m_ptr  << endl;
    delete m_ptr;
    m_ptr = nullptr;
 }
private:
  int* m_ptr;
};
// 为了避免返回值优化，此函数故意这样写
A Get(bool flag)
{
  A a;
  A b;
  cout << "ready return" << endl;
  if (flag)
    return a;
  else
    return b;
}
int main()
{
 {
    A a = Get(false); 
 }
  cout << "main finish" << endl;
  return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
  A() :m_ptr(new int(0)) {
    cout << "constructor A"  << endl;
 }
  A(const A& a) :m_ptr(new int(*a.m_ptr)) {
    cout << "copy constructor A"  << endl;
 }
  ~A(){
    cout << "destructor A, m_ptr:" << m_ptr  << endl;
    delete m_ptr;
    m_ptr = nullptr;
 }
private:
  int* m_ptr;
};
// 为了避免返回值优化，此函数故意这样写
A Get(bool flag)
{
  A a;
  A b;
  cout << "ready return" << endl;
  if (flag)
    return a;
  else
    return b;
}
int main()
{
 {
     A a = Get(false); // 正确运行
 }
  cout << "main finish" << endl;
  return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
  A() :m_ptr(new int(0)) {
    cout << "constructor A"  << endl;
 }
 // 深拷贝
  A(const A& a) :m_ptr(new int(*a.m_ptr)) {
    cout << "copy constructor A"  << endl;
 }
// 移动构造函数，可以浅拷贝
  A(A&& a) :m_ptr(a.m_ptr) {
    a.m_ptr = nullptr;  // 为防止a析构时delete data，提前置空其m_ptr
    cout << "move constructor A"  << endl;
 }
  ~A(){
    cout << "destructor A, m_ptr:" << m_ptr  << endl;
    if(m_ptr)
      delete m_ptr;
 }
private:
  int* m_ptr;
};
// 为了避免返回值优化，此函数故意这样写
A Get(bool flag)
{
  A a;
  A b;
  cout << "ready return" << endl;
  if (flag)
    return a;
  else
    return b;
}
int main()
{
 {
    A a = Get(false); // 正确运行
 }
  cout << "main finish" << endl;
  return 0;
}

Template<class T>
void func(T &&val);

int &&a = 10;
int &&b = a; //错误

int &&a = 10;
int &&b = std::forward<int>(a);

#include <iostream>
using namespace std;
template <class T>
void Print(T &v)
{
  cout << "L" << v << endl;
}
template <class T>
void Print(T &&v)
{
  cout << "R" << v << endl;
}
template <class T>
void func(T &&v)
{
  Print(v);
  Print(std::move(v));  // move返回的是右值引用
  Print(std::forward<T>(v));   // 按参数原来的类型转发，比如fun(1),此时v原来是右值
}
int main()
{
  cout << "-- func(1)" << endl;
  func(1); // 1是右值，但是T &&v = 1， v本身是左值
  cout << "\n-- func(x)" << endl;
  int x = 10;
  int y = 20;
  func(x);  // x本身是左值
  cout << "\n-- func(std::forward<int>(y))" << endl;
  func(std::forward<int>(y)); //T为int，以右值方式转发y
  cout << "\n-- func(std::forward<int&>(y))" << endl;
  func(std::forward<int&>(y));  // T为int&，以左值方式转发y
  cout << "\n-- func(std::forward<int&&>(y))" << endl;
  func(std::forward<int&&>(y));
  return 0;
}

#include "stdio.h"
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
class A
{
public:
  A() : m_ptr(NULL), m_nSize(0) {}
  A(int *ptr, int nSize)
 {
    m_nSize = nSize;
    m_ptr = new int[nSize];
    printf("A(int *ptr, int nSize) m_ptr:%p\n", m_ptr);
    if (m_ptr)
   {
      memcpy(m_ptr, ptr, sizeof(sizeof(int) * nSize));
   }
 }
  A(const A &other) // 拷贝构造函数实现深拷贝
 {
    m_nSize = other.m_nSize;
    if (other.m_ptr)
   {
      printf("A(const A &other) m_ptr:%p\n", m_ptr);
      if(m_ptr)
        delete[] m_ptr;
      printf("delete[] m_ptr\n");
      m_ptr = new int[m_nSize];
      memcpy(m_ptr, other.m_ptr, sizeof(sizeof(int) * m_nSize));
   }
      else
   {
      if(m_ptr)
        delete[] m_ptr;
      m_ptr = NULL;
   }
    cout << "A(const int &i)" << endl;
 }
  // 右值引用移动构造函数
  A(A &&other)
 {
    m_ptr = NULL;
    m_nSize = other.m_nSize;
    if (other.m_ptr)
   {
      m_ptr = move(other.m_ptr); // 移动语义
      other.m_ptr = NULL;
   }
 }
  ~A()
 {
    if (m_ptr)
   {
      delete[] m_ptr;
      m_ptr = NULL;
   }
 }
  void deleteptr()
 {
    if (m_ptr)
   {
      delete[] m_ptr;
      m_ptr = NULL;
   }
 }
  int *m_ptr = NULL;  // 增加初始化
  int m_nSize = 0;
};
int main()
{
  int arr[] = {1, 2, 3};
  A a(arr, sizeof(arr) / sizeof(arr[0]));
  cout << "m_ptr in a Addr: 0x" << a.m_ptr << endl;
  cout<< "================" <<endl;
  A b(a);
  cout << "m_ptr in b Addr: 0x" << b.m_ptr << endl;
  b.deleteptr();
  cout<< "================" <<endl;
  A c(std::forward<A>(a)); // T为A，以右值方式完美转换a
  cout << "m_ptr in c Addr: 0x" << c.m_ptr << endl;
  c.deleteptr();
  cout<< "================" <<endl;
  vector<int> vect{1, 2, 3, 4, 5};
  cout << "before move vect size: " << vect.size() << endl;
  vector<int> vect1 = move(vect);
  cout << "after move vect size: " << vect.size() << endl;
  cout << "new vect1 size: " << vect1.size() << endl;
  return 0;
}

vector<string> testVec;
testVec.push_back(string(16, 'a'));