【仿写实现move函数】-编程知识

仿写实现move函数

一、值的类型

在这里插入图片描述

1.左值

描述：能够取地址的值成为左值

int a = 10;
const int b = 15;
int *pa = &a;
const int *pb = &b;

2.纯右值

描述：赤裸裸的字面值 eg(false , 3 , 12.23等)

int a = 13;
int *p = &a;  //取a的地址
int *ptr = &13; //错误，13是一个字面量，无法取地址

如字面常量 103， 12.23， nullptr；不可以取地址，称为为纯右值。

3.将亡值

描述：表达式的运行或计算过程中所产生的临时量或临时对象，称之为将亡值；临时量有可能是字面值，也有可能是一个不具名的对象。

算术表达式（a+b …），逻辑表达式（a || b …），比较表达式（a != b …）取地址表达式（&b)等，产生的计算结果相当于字面量，实际存储在 cpu的寄存器中，因为计算结果是字面量，所以为纯右值。

如图在这里插入图片描述

因为c++是面向对象的，所以 i++ 和 ++i 是不一样的， ++i 相当于 i = i + 1；所以不会产生临时变量，而 i++不同，它相当于将 i 拷贝一份当做副本，然后将原来的 i 进行加 1 操作，最后将副本的值返回。 副本是不具名的，所以是 将亡值，而返回的值是字面量所以 i++ 为纯右值 。

不具名对象如图

在这里插入图片描述

编译后会报错 test.cpp(17): error C2102: “&”要求左值,。

因为 Int(13) 程序运行过程中所产生了不具名对象，将亡值。不可以取地址, 所以&Int(13)错误。

int fun()
{int value = 10;return value;
}
int main()
{int i = 0;int a = 1;i = a + b;i++;&b;a = fun(); //返回时在主栈帧中构造临时量，是将亡值，纯右值。return 0;
}

流程图 图 2.2

在这里插入图片描述

当fun函数return 时，其栈帧空间会被回收，此时先在主栈帧中创建一个将亡值对象(xvalue) 将返回的值赋给将亡值，回到主函数栈帧中会再将将亡值对象的值赋给 a.

二、引用

基本原则：

1.声明引用的时候必须初始化，且一旦绑定，不可把引用绑定到其他对象；即引用必须初始化，不能对引用重定义

2.对引用的一切操作，就相当于对原对象的操作

1.引用与函数重载

void fun(int& val)
{cout << "LeftRef" << endl;
}
void fun(const int & val)
{cout << "Const LeftRef" << endl;
}
void fun(int&& val)
{cout << "RightRef" << endl;
}
int main()
{int a = 10; const int d = 15;int&& f = 12; //右值引用f是具名右值引用，编译器会将已命名的右值引用视为左值//int&& g = f;  // error,f为具名右值fun(a);  fun(d);fun(f);fun(13);return 0;
}

运行结果：

在这里插入图片描述

结论：

1.int& a = 10; 右值引用 a 是具名右值引用。

2.编译器会将已命名的右值引用视为左值,所以不能 int && b = a;

2.函数返回值

int func()
{int x = 10;cout<<"&x: "<<endl;return x;
}int main()
{int a = func();//int& b = func(); // error; func返回值为右值.const int& c = func(); cout << "&c: " << &c << endl;int&& d = func();cout << "&d: " << &d << endl;return 0;
}

运行结果：

在这里插入图片描述

结论：1.函数返回值为将亡值（右值）

2.常性左值引用为万能引用，可以接受右值

3.自定义类

class Int  
{int val;
public:Int(int x = 0) :val(x){cout << "Create Int: " << this << endl;}Int(const Int& it) :val(it.val){cout << this<<" Copy Create Int: <= " << &it << endl;}Int(Int&& it) :val(it.val){it.val = 0;cout << this<<" Move Create Int: <= " << &it << endl;}Int& operator=(const Int& it){if (this == &it) return *this;val = it.val;cout << this << " = " << &it << endl;return *this;}Int& operator=(Int&& it){if (this == &it) return *this;val = it.val;it.val = 0;cout << this << " <= " << &it << endl;return *this;}~Int() { cout << "Destroy Int: " << this << endl; } 
};Int func(int x)
{Int tmp(x);return tmp;
}int main()
{Int a = func(1);cout << "--------------------" << endl;Int x(0);cout << "--------------------" << endl;x = func(2);cout << "--------------------" << endl;//Int& b = func(3);const Int& c = func(4);cout << "--------------------" << endl;Int&& d = func(5);cout << "--------------------" << endl; Int f(a);cout << "--------------------" << endl;return 0;
}

运行结果

在这里插入图片描述

结论：

1.通过右值引用，比之前少了一次移动构造和一次析构，原因在于右值引用绑定了右值，让临时右值的生
命周期延长了 <主栈帧里创建的不具名对象(将亡值)>

2.函数返回值构建过程和之前分析的一样（ 图 2.2 ）

三、std::move的实现

原理：

本质上是将左值强制转换为右值引用，调用对象的移动构造和移动赋值函数，实现对资源的转移。

优点：

当一个对象内部有较大的堆内存或者动态数组时，进行深拷贝会占用cpu资源，而浅拷贝释放资源时会造成对堆区进行重复释放导致非法访问。使用move()语义可以提高性能

使用范围：

move 对于拥有形如对内存、堆区等资源的成员的对象有效

1.未定义的引用类别 && （函数模板中）

template <class _Ty>
void fun(_Ty&&  x) //未定义的引用类型，它必须被初始化，它是左值还是右值引用，取决于它的初始化
{int z = 10;_Ty y = z;
}
int main()
{int a = 1;const int b = 2;int& c = a;const int& d = b;fun(10);  fun(a);fun(b);fun(c);fun(d);return 0;
}

fun(b),fun(d)：x的类型为 const int& ,y的类型为const int&;

fun(10)：x的类型为 int&& , y 的类型为 int,不具有引用；

结论：

_Ty && 与左值，普通左值引用结和，_Ty为左值引用
_Ty&& 与左值常引用结合，_Ty为左值常性引用
_Ty&& 与右值结合时，_Ty只保留类型，不具有引用属性
_Ty&& 不会破坏掉对象的const属性

实现流程：

1.我们需用取出对象的引用属性

template <class _Ty>
struct my_remove_reference
{using type = _Ty;my_remove_reference(){cout << "_Ty" << endl;}
};
template <class _Ty>
struct my_remove_reference<_Ty &>
{using type = _Ty;my_remove_reference(){cout << "_Ty" << endl;}
};
template <class _Ty>
struct my_remove_reference<_Ty &&>
{using type = _Ty;my_remove_reference(){cout << "_Ty" << endl;}
};

2.加入适配器，使其具有普适性

template <class _Ty>
using my_remove_reference_t = typename my_remove_reference<_Ty>::type;

3.转换为右值

template <class _Ty>
my_remove_reference_t<_Ty> && my_move(_Ty &&x)
{return static_cast<my_remove_reference_t<_Ty>&&>(x);
}

典型错误：使用c语言中的强制类型转换

template <class _Ty>
my_remove_reference_t<_Ty> && my_move(_Ty &&x)
{ return (my_remove_reference_t<_Ty>&&)x; //error,不能使用c语言中的强制类型转换
}

因为常性对象的资源是不能进行移动修改的，而强制类型转换会破坏这一平衡点，而c++的静态类型转换刚好不会去掉const属性。