【仿写C++中的move函数和forward函数】

已于 2023-11-25 21:42:00 修改
阅读量228 收藏 1
点赞数
分类专栏： c++ 文章标签： c++
于 2023-11-25 18:14:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63282188/article/details/134618030
版权

仿写实现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(a),fun©： x 的类型为 int& ，y的类型为 int&;

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

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

结论：

  1. _Ty && 与左值，普通左值引用结和，_Ty为左值引用

  2. _Ty&& 与左值常引用结合，_Ty为左值常性引用

  3. _Ty&& 与右值结合时，_Ty只保留类型，不具有引用属性

  4. _Ty&& 不会破坏掉 对象的const属性

实现流程：

1.我们需用去除对象的引用属性
template <class _Ty>
struct my_remove_reference
{
    using type = _Ty;

};
template <class _Ty>
struct my_remove_reference<_Ty &>
{
    using type = _Ty;

};
template <class _Ty>
struct my_remove_reference<_Ty &&>
{
    using type = _Ty;
    
};
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属性。

四、实现forward函数

原理：

利用引用叠加，按照参数原来的值类型转发到另一个函数

先来看std::forward()函数示例

void print(int& val)
{
    cout<<"LReference"<<endl;
}
void print(const int& val)
{
    cout<<"const LReference"<<endl;
}
void print(int&& val)
{
    cout<<"RReference"<<endl;
}
 
 template<class _Ty>
 void fun(_Ty&& val)
 {
    print(std::forward<_Ty>(val));
 }

int main()
{
  int a = 10;
  const int b = 20;
  int& c = a;
  fun(a);
  fun(b);
  fun(c);
  fun(10);
  system("pause"); 
}

运行结果

在这里插入图片描述

引用叠加：

由于存在 (_Ty&&) 这种未定的引用类型，当它作为参数时，可能被一个左值引用或者右值引用的参数初始化，这时经过类型推导的 _Ty 和右值引用（&&）叠加会发生类型的变化，这种变化被称为引用折叠。

即 static_cast<_Ty &&> (val);

c++中规定：

  1. 所有的右值引用叠加到右值引用上仍然还是一个右值引用。

  2. **所有的其他引用类型之间的叠加都将变成左值引用。

设计forward的参数

  1. 需要接受所有类型的数据 -> 联想到万能引用

  2. 需要保留原来数据的类型 -> 联想到去除引用属性的模板

去除引用属性的模板代码在上文move()函数实现中

1.左值版

template <class _Ty>
_Ty&& my_forward(my_remove_reference_t<_Ty>& Arg)//_Ty保留数据原来的属性
{
    return static_cast<_Ty &&> (Arg);  //此处涉及引用折叠
}

2.右值版 （forward还应支持右值参数）

template <class _Ty>
_Ty&& my_forward(my_remove_reference_t<_Ty>&& Arg)
{
    return static_cast<_Ty &&> (Arg);  //此处涉及引用折叠
}

这样就可以实现和系统的forward相同的功能

测试代码

template <class _Ty>
struct my_remove_reference
{
    using type = _Ty;

};
template <class _Ty>
struct my_remove_reference<_Ty &>
{
    using type = _Ty;

};
template <class _Ty>
struct my_remove_reference<_Ty &&>
{
    using type = _Ty;

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

template <class _Ty>
_Ty &&my_forward(my_remove_reference_t<_Ty> &_Arg)
{
    return static_cast<_Ty &&>(_Arg);
}
template <class _Ty>
_Ty &&my_forward(my_remove_reference_t<_Ty> &&_Arg)
{
    return static_cast<_Ty &&>(_Arg);
}
void print(int& val)
{
    cout<<"LReference"<<endl;
}
void print(const int& val)
{
    cout<<"const LReference"<<endl;
}
void print(int&& val)
{
    cout<<"RReference"<<endl;
}
 template<class _Ty>
 void fun(_Ty&& val)
 {
    print(my_forward<_Ty>(val));
 }

int main()
{
  int a = 10;
  const int b = 20;
  int& c = a;
  fun(a);
  fun(b);
  fun(c);
  fun(10);
  print(my_forward(10));//右值版
}
槐夏风清7
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
仿写C++ STL标准库 vector 容器
08-26
仿写C++ STL标准库 vector 源码，可直接在cpp文件中调用实现
C++仿写wavelet分解去噪方法
10-16
总结，通过C++实现小波分解去噪，我们可以有效地从复杂信号中分离出纯净的信号成分，提高数据处理的准确性和可靠性。这一方法广泛应用于图像处理、音频去噪、地震数据分析等多个领域。理解并熟练掌握小波分解技术，...
open--C语言常用函数
forward_huan的博客
06-23 348
open --C语言常用函数 include<fcntl.h> 定义函数： int open(const char * pathname, int flags) int open(const char * pathname, int flags, mode_t mode) 返回值： 成功则返回文件描述符，否则返回 -1 flags O_RDONLY 以只读方式打开文件 O_WRONLY 以只写方式打开文件 O_RDWR 以可读写方式打开文件. 上述三种旗标是互斥的, 也就是不可同时使用, 但可
C++ | STL : vector的介绍和使用
Sauron7i的博客
04-09 896
文章目录一、vector简介二、vector的使用1.构造函数 一、vector简介 vector是表示可以改变大小的数组的序列容器。 vector与数组一样，元素使用连续的存储空间，就可以使用常规指针，指向其元素，使用偏移量来访问存储空间中的元素。 vector 与数组不同的是，vector的大小可以动态变化，容器会自动扩容存储空间。 vector使用一个动态分配的连续存储空间来存储元素。在插入新元素时存储空间可能需要重新分配，以便增大大小,这意味着分配一个新存储空间要将所有元素移动到其中。就处理时间而
C++：std::move()和完美转发的仿，auto、decltype关键字，NULL和nullptr 的简单理解（笔记自用）
Sauron7i的博客
05-13 424
C++：std::move()和完美转发的仿，auto、decltype关键字，NULL和nullptr 的简单理解
【std::move源码剖析】
qq_35497125的博客
11-20 66
std::move()函数源码剖析
C++归总学习
wuguinianjing的博客
10-19 472
1 类与对象 封装是面向对象程序设计最基本的特性，把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。 现实世界中的实体可以抽象出类别的概念。对应于计算机世界就有一个类（class）的概念，因为类是一个抽象的概念的对应体，所以计算机不给它分配内存，只给对象分配内存。 class CGoods{ public : char Name[21] ; //对于中文可用wchar_t name[11] int Amount ; float Pric
【C++智能指针】unique_ptr的源码详解以及应用实例
b_r_ight的博客
04-21 1157
C++11智能指针的原理和使用
C++:线上课程2_26（vector）
小柒的秃头之路
04-10 593
文章目录一、Vector1. vector 源码剖析与仿写2. 容器初始化3. 元素访问4. 迭代器二、1.2. 一、Vector 1. vector 源码剖析与仿写 vector简介: 1.vector是表示可以改变大小的数组的序列容器。// SegList 2.vector与数组一样，元素使用连续的存储空间，就可以使用常规指针，指向其元素，使用偏移量来访问存储空间中的元素。 3.vector与数组不同的是，vector的大小可以动态变化，容器会自动扩容存储空间。 4.vector使用一个动态分配的连续
C++11新特性 智能指针 unique_ptr shared_ptr weak_ptr 交叉引用
IT_涛涛
07-01 294
C++智能指针 唯一性指针 共享性指针 弱指针
C++模拟标准库容器vector
David_TD的博客
01-07 179
使用模板写出简易版的标准库容器vector。主要使用了allocator来进行分配内存。代码存在大量注释。故实现细节查看代码 ///头文件Vec.h #pragma once #ifndef VEC_H #define VEC_H #include &amp;lt;initializer_list&amp;gt; #include &amp;lt;allocators&amp;gt; #include &amp;lt;memory&amp;gt...
【智能指针1】unique_ptr源码剖析
m0_37957950的博客
06-15 1713
C++智能指针的源码剖析。
C++仿写string类
07-20
使用C++语言仿写STL中的string
MyString 字符串类仿写_C++_（四种版本，引用计数，迭代器，加锁）
12-10
在C++编程中，自定义字符串类是一种常见的练习，它能帮助我们深入理解字符串操作的底层机制。这里我们将探讨一个名为"MyString"的自定义字符串类的四个不同版本，每个版本都增加了特定的功能，如引用计数、写时拷贝...
C++string类仿写
05-30
C++的一般编译器都定义和封装了字符串功能，请模仿定义string类的实现，可以实现并支持如下功能： （1）string s = “rubbish大学”； （2）string t = s; （3）string m； m = t； （4）m.legnth() 函数测量字符串...
函数模板与类模板
最新发布
程序员_小兵
07-12 1296
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
初始C++
2302_81016149的博客
07-08 801
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++ 多态
wxk2227814847的博客
07-10 760
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++初探究（2）
Frenemy__的博客
07-09 1469
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
仿写sprintf函数
10-19
如果你想仿写sprintf函数，可以按照以下步骤进行： 1. 定义一个函数，函数名为mysprintf，参数列表包括一个字符指针buf和一个常量字符指针fmt，以及可变参数列表。 2. 在函数内部定义一个变量len，用于记录写入字符...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值