c++之说_14|左值引用与右值引用

最新推荐文章于 2024-06-12 18:28:23 发布
最新推荐文章于 2024-06-12 18:28:23 发布
阅读量578 收藏 6
点赞数 17
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59398646/article/details/136093879
版权

提起左右值引用我就头疼

左值：

1、在内存中开辟了空间的便叫左值

2、左值不一定可以赋值  如字符串常量

3、左值可以取地址

右值：

1、在内存中没有开辟空间的

2、右值无法取地址

如：

立即数（1，2，3）

函数返回值 直接返回非类型引用

Lvalue getT() { return Lvalue(); };
int get() { return c;  };

返回的这个int值或Lvalue类型对象就是一个右值 因为没有开辟空间

3、将亡值

什么叫将亡值  我的理解是一种标志 告诉说这个对象我要销毁

Lvalue&& getR();  函数返回值是右值引用 返回的这个对象 就叫将亡对象  即将销毁


Lvalue c;
static_cast<Lvalue&&>(c);  转换返回的操作数也叫将亡值

我的理解就是告诉我们 这个值是要销毁的  推荐使用一个新对象去存储

  什么叫左值引用？ 其实就是 这个对象所代表的内存空间的另一个名字  在编译器内部

  本质上是指针实现的

   对左值引用取地址  所取的是引用对象的地址值

Lvalue d;//左值

const Lvalue& b2 = d;//绑定左值
Lvalue& b3 = d;//绑定左值

&b2 == &d;
&b3 == &d;

而右值引用 则引用的是右值

Rvalue r;//左值
Rvalue&& r1 = Rvalue();//绑定右值

//r1 是左值  有名的右值引用  为 左值
const Rvalue&& r2 = static_cast<Rvalue&&>(r1);//绑定右值（实际上是左值转换到右值）成将亡值

Rvalue&& r3 = static_cast<Rvalue&&>(r);

记住有名字的右值引用  是左值  所以可以取地址

std::cout << "r:" << &r << endl;
std::cout << "r1:" << &r1 << endl;
std::cout << "r2:" << &r2 << endl;
std::cout << "r3:" << &r3 << endl;

&r == &r3;
&r1 == &r2;

由于是引用  当然可以改变所引用的对象

struct Rvalue
{


};
struct Lvalue : public Rvalue
{
	int c;
	Lvalue() = default;
	Lvalue(int Inc) :c(Inc) {};

	Lvalue getT() { return Lvalue(); };
	Lvalue&& getR() { 
		auto c = new Lvalue(100);  
		return static_cast<Lvalue&&>(*c);
	};
	int get() { return c;  };
};
std::cout << "" << endl;
Lvalue op(50);
std::cout << "op.c：" << op.c << endl;
Lvalue& Lop = op;
Lop.c = 100;
std::cout << "左值引用修改"<< endl;
std::cout << "op.c：" << op.c << endl;
Lvalue& Rop = op;
Lop.c = 800;
std::cout << "右值引用修改" << endl;
std::cout << "op.c：" << op.c << endl;

这么一看左右值引用都是一样的感觉

他们主要体现在函数上

struct Lvalue : public Rvalue
{
	int c;
	int* p;
	Lvalue() = default;
	Lvalue(int Inc) :c(Inc), p(new int()) {};


	Lvalue& operator=(Lvalue& lc) 
	{ 
		c = lc.c;
		p = new int;
		*p = * lc.p;
		return *this; 
	};
	Lvalue& operator=(const Lvalue& lc) 
	{
		c = lc.c;
		p = new int;
		*p = *lc.p;
		return *this; 
	};
	Lvalue& operator=(Lvalue&& lc) 
	{
		c = lc.c;
		p = lc.p;
		lc.p = nullptr;
		return *this;
	};
	Lvalue& operator=(const Lvalue&& lc) 
	{	
		Lvalue&& Rc = const_cast<Lvalue&&> (lc);
		c = Rc.c;
		p = Rc.p;
		Rc.p = nullptr;

		return *this; 
	};


	Lvalue getT() { return Lvalue(); };
	Lvalue&& getR() { 
		auto c = new Lvalue(100);  
		return static_cast<Lvalue&&>(*c);
	};
	int get() { return c;  };
};

注意那几个 operator= 重载赋值运算符的函数

这其实就是所谓的 深拷贝  浅拷贝

//深拷贝
Lvalue& operator=(Lvalue& lc) 
{ 
	c = lc.c;
	p = new int;    //重新开辟了堆空间 
	*p = * lc.p;    //将 lc.p 中的int值 存入新开的堆空间中
	return *this; 
};

//浅拷贝
Lvalue& operator=(Lvalue&& lc) 
{
	c = lc.c;
	p = lc.p;        
//没有开辟新的堆空间  直接拿到 将亡值 lc 的 p所存储的内存地址  达到复用的目的
// 这也是他们所说的窃取资源
	lc.p = nullptr;
	return *this;
};
Lvalue& operator=(Lvalue& lc) 
{ 
	std::cout << "Lvalue& operator=(Lvalue& lc)" << endl;
	c = lc.c;
	delete p;
	p = new int;
	*p = * lc.p;
	return *this; 
};
Lvalue& operator=(const Lvalue& lc) 
{
	std::cout << "Lvalue& operator=(const Lvalue& lc)" << endl;
	c = lc.c;
	delete p;
	p = new int;
	*p = *lc.p;
	return *this; 
};
Lvalue& operator=(Lvalue&& lc) 
{
	std::cout << "Lvalue& operator=(Lvalue&& lc) " << endl;
	c = lc.c;
	delete p;
	p = lc.p;
	lc.p = nullptr;
	return *this;
};
Lvalue& operator=(const Lvalue&& lc) 
{	
	std::cout << "Lvalue& operator=(const Lvalue&& lc) " << endl;
	Lvalue&& Rc = const_cast<Lvalue&&> (lc);
	c = Rc.c;
	delete p;
	p = Rc.p;
	Rc.p = nullptr;

	return *this; 
};

调用处

Lvalue t1(100);
*t1.p = 80;
Lvalue t2(200);
*t2.p = 800;
std::cout << "" << endl;
std::cout << "初始化时" << endl;
std::cout << "t1.c：" << t1.c << endl;
std::cout << "t1.p：" << t1.p << endl;
std::cout << "*t1.p：" << *t1.p << endl;
std::cout << "" << endl;
std::cout << "t2.c：" << t2.c << endl;
std::cout << "t12.p：" << t2.p << endl;
std::cout << "*t2.p：" << *t2.p << endl;

std::cout << "" << endl;
std::cout << "t1 = t2" << endl;

t1 = t2;//Lvalue& operator=(Lvalue& lc) ；

std::cout << "t1.c：" << t1.c << endl;
std::cout << "t1.p：" << t1.p << endl;
std::cout << "*t1.p：" << *t1.p << endl;
std::cout << "" << endl;
std::cout << "t2.c：" << t2.c << endl;
std::cout << "t12.p：" << t2.p << endl;
std::cout << "*t2.p：" << *t2.p << endl;


std::cout << "" << endl;
std::cout << "t1 = static_cast<Lvalue&&>(t2)" << endl;

t1 = static_cast<Lvalue&&>(t2); 
//Lvalue& operator=(Lvalue&& lc)  如果没有  就考虑 Lvalue& operator=(const Lvalue&& lc)  
如果还没有 就调用Lvalue& operator=(const Lvalue& lc) 

std::cout << "t1.c：" << t1.c << endl;
std::cout << "t1.p：" << t1.p << endl;
std::cout << "*t1.p：" << *t1.p << endl;
std::cout << "" << endl;
std::cout << "t2.c：" << t2.c << endl;
std::cout << "t12.p：" << t2.p << endl;
//std::cout << "*t2.p：" << *t2.p << endl; //访问空指针是错误的

我们注释掉

/* Lvalue& operator=(Lvalue&& lc) 
{
	std::cout << "Lvalue& operator=(Lvalue&& lc) " << endl;
	c = lc.c;
	delete p;
	p = lc.p;
	lc.p = nullptr;
	return *this;
}; 
  */

Lvalue& operator=(const Lvalue&& lc) 
{	
	std::cout << "Lvalue& operator=(const Lvalue&& lc) " << endl;
	Lvalue&& Rc = const_cast<Lvalue&&> (lc);
	c = Rc.c;
	delete p;
	p = Rc.p;
	Rc.p = nullptr;

	return *this; 
};

看调用 Lvalue& operator=(const Lvalue&& lc) 

我们继续注释

/* Lvalue& operator=(Lvalue&& lc) 
{
	std::cout << "Lvalue& operator=(Lvalue&& lc) " << endl;
	c = lc.c;
	delete p;
	p = lc.p;
	lc.p = nullptr;
	return *this;
}; 
  */

/*
Lvalue& operator=(const Lvalue&& lc) 
{	
	std::cout << "Lvalue& operator=(const Lvalue&& lc) " << endl;
	Lvalue&& Rc = const_cast<Lvalue&&> (lc);
	c = Rc.c;
	delete p;
	p = Rc.p;
	Rc.p = nullptr;

	return *this; 
};
*/

看调用与结果

这就是右值引用存在的价值

告诉大家这个对象需要销毁  你怎么处理看你的了  

如果只用左值引用 无法很好的区分  因为cosnt lvalue&&  即可左值也可右值

你不知道传进来的这个对象是 const 修饰的对象  还是  要表示的销毁对象

我们也看到了引用是可以直接修改对象的  所以也是会有点问题  有些人不按照规则来

这样的函数 是有隐患的  我的本意是  这个返回值是即将销毁的值  然而外部可修改

Lvalue&& getR() { 
	auto c = new Lvalue(100);  
	return static_cast<Lvalue&&>(*c);
};

折叠引用  使用类型别名  using  typedef  即可达到折叠引用的目的

using ob = Lvalue&;
typedef Lvalue& ob1;
using ou = Lvalue&&;
typedef Lvalue&& ou1;

Lvalue k;
ob& o = k;//左值引用
ob && o1= k;//左值引用
ou& o2 = k;//左值引用
ou&& o3 = (Lvalue&&)k;//右值引用

折叠引用只有一个规则：

右值引用的右值引用 才是右值引用  其余都为左值引用

&& &&  右值引用

& && 左值引用

&& & 左值引用

& & 左值引用

而我们所知晓的 std::forward 完美转发  返回值就是  &&

用了点折叠引用

好了  到最后了 

我们说一下

空类 和 继承 一个空类 内存大小是什么样的

Lvalue d;//左值
Rvalue r;//左值
std::cout<<	sizeof(d)<<endl;//4   继承一个空类  空类所占的1字节被优化掉
std::cout << sizeof(r) << endl;//1

  写完了

对了知乎大佬的参考  左右值引用的要点  

(3 条消息) c++为什么要搞个引用岀来，特别是右值引用，感觉破坏了语法的简洁和条理，拷贝一个指针不是很好吗？ - 知乎 (zhihu.com)

最后参考代码


struct Rvalue
{


};
struct Lvalue : public Rvalue
{
	int c;
	int* p;
	Lvalue() = default;
	Lvalue(int Inc) :c(Inc), p(new int()) {};


	Lvalue& operator=(Lvalue& lc) 
	{ 
		std::cout << "Lvalue& operator=(Lvalue& lc)" << endl;
		c = lc.c;
		delete p;
		p = new int;
		*p = * lc.p;
		return *this; 
	};
	Lvalue& operator=(const Lvalue& lc) 
	{
		std::cout << "Lvalue& operator=(const Lvalue& lc)" << endl;
		c = lc.c;
		delete p;
		p = new int;
		*p = *lc.p;
		return *this; 
	};
	/*Lvalue& operator=(Lvalue&& lc) 
	{
		std::cout << "Lvalue& operator=(Lvalue&& lc) " << endl;
		c = lc.c;
		delete p;
		p = lc.p;
		lc.p = nullptr;
		return *this;
	};*/
	/*Lvalue& operator=(const Lvalue&& lc) 
	{	
		std::cout << "Lvalue& operator=(const Lvalue&& lc) " << endl;
		Lvalue&& Rc = const_cast<Lvalue&&> (lc);
		c = Rc.c;
		delete p;
		p = Rc.p;
		Rc.p = nullptr;

		return *this; 
	};*/


	Lvalue getT() { return Lvalue(); };
	Lvalue&& getR() { 
		auto c = new Lvalue(100);  
		return static_cast<Lvalue&&>(*c);
	};
	int get() { return c;  };
};

int main(int line,   const char* arg[])
{
	Lvalue d;//左值
	Rvalue r;//左值
	std::cout<<	sizeof(d)<<endl;//4   继承一个空类  空类所占的1字节被优化掉
	std::cout << sizeof(r) << endl;//1

	//const 修饰的左值引用 既可以绑定左值又可以绑定右值     Lvalue() 右值  无名的
	const Lvalue& b = Lvalue();//绑定右值
	const Lvalue& b2 = d;//绑定左值
	Lvalue& b3 = d;//绑定左值
	
	Rvalue&& r1 = Rvalue();//绑定右值
	//r1 是左值  有名的右值引用  为 左值
	const Rvalue&& r2 = static_cast<Rvalue&&>(r1);//绑定右值（实际上是左值转换到右值）
	Rvalue&& r3 = static_cast<Rvalue&&>(r);
	
	//std::move(r);
	std::cout << "左值"<< endl;

	std::cout << "d:"<< & d << endl;
	std::cout << "b2:"<< &b2 << endl;
	std::cout << "b:" << &b << endl;
	std::cout << "b3:" << &b3 << endl;

	std::cout << "右值"<< endl;

	std::cout << "r:" << &r << endl;
	std::cout << "r1:" << &r1 << endl;
	std::cout << "r2:" << &r2 << endl;
	std::cout << "r3:" << &r3 << endl;
	
	//td::cout << "纯右值" << &Rvalue() << endl; //error
	//&d.getT();
	decltype(auto) v = d.getR();
	v.c = 50;
	std::cout << "v：" << &v << endl;
	
	auto str = "dadad";
	std::cout << "字符串：" << &"dadad" << endl;
	std::cout << "str：" << &str << endl;

	std::cout << "" << endl;
	Lvalue op(50);
	std::cout << "op.c：" << op.c << endl;
	Lvalue& Lop = op;
	Lop.c = 100;
	std::cout << "左值引用修改"<< endl;
	std::cout << "op.c：" << op.c << endl;
	Lvalue& Rop = op;
	Lop.c = 800;
	std::cout << "右值引用修改" << endl;
	std::cout << "op.c：" << op.c << endl;

	int&& i = 10;
	i = 80;

	
	
	Lvalue t1(100);
	*t1.p = 80;
	Lvalue t2(200);
	*t2.p = 800;
	std::cout << "" << endl;
	std::cout << "初始化时" << endl;
	std::cout << "t1.c：" << t1.c << endl;
	std::cout << "t1.p：" << t1.p << endl;
	std::cout << "*t1.p：" << *t1.p << endl;
	std::cout << "" << endl;
	std::cout << "t2.c：" << t2.c << endl;
	std::cout << "t12.p：" << t2.p << endl;
	std::cout << "*t2.p：" << *t2.p << endl;
	
	std::cout << "" << endl;
	std::cout << "t1 = t2" << endl;

	t1 = t2;//Lvalue& operator=(Lvalue& lc) ；
	
	std::cout << "t1.c：" << t1.c << endl;
	std::cout << "t1.p：" << t1.p << endl;
	std::cout << "*t1.p：" << *t1.p << endl;
	std::cout << "" << endl;
	std::cout << "t2.c：" << t2.c << endl;
	std::cout << "t12.p：" << t2.p << endl;
	std::cout << "*t2.p：" << *t2.p << endl;


	std::cout << "" << endl;
	std::cout << "t1 = static_cast<Lvalue&&>(t2)" << endl;
	
	t1 = static_cast<Lvalue&&>(t2); //Lvalue& operator=(Lvalue&& lc)  如果没有  就考虑 Lvalue& operator=(const Lvalue&& lc)  如果还没有 就调用Lvalue& operator=(const Lvalue& lc) 
	
	std::cout << "t1.c：" << t1.c << endl;
	std::cout << "t1.p：" << t1.p << endl;
	std::cout << "*t1.p：" << *t1.p << endl;
	std::cout << "" << endl;
	std::cout << "t2.c：" << t2.c << endl;
	std::cout << "t12.p：" << t2.p << endl;
	//std::cout << "*t2.p：" << *t2.p << endl; //访问空指针是错误的
	using ob = Lvalue&;
	typedef Lvalue& ob1;
	using ou = Lvalue&&;
	typedef Lvalue&& ou1;

	Lvalue k;
	ob& o = k;//左值引用
	ob && o1= k;//左值引用
	ou& o2 = k;//左值引用
	ou&& o3 = (Lvalue&&)k;//右值引用
	
	std::forward<Lvalue&&>(k);
	return 0;
}

普世的微光
关注
  • 17
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11 新特性 ② | 左值、左值引用、右值与右值引用
dvlinker的技术专栏
09-07 1万+
详细讲述左值、左值引用、右值与右值引用相关概念。
【C++11】左值引用和右值引用
学了就忘是正常现象
04-06 1733
右值引用通过移动构造和移动赋值，解决了左值引用值返回多次构造的消耗。 同时插入右值场景，调用移动构造，减少拷贝，提高性能。
详解 C++ 左值、右值、左值引用以及右值引用
热门推荐
Butayarou的博客
07-25 1万+
主要讲解了 C++11 的右值引用（及其支持的移动语义和完美转发）。
C++ 左值引用与右值引用
qq_41521068的博客
11-25 973
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能 取地址。func1与func3没有使用左值引用做参数或返回值，所以进行了深拷贝，通过fun2与func4的调用我们可以看出左值引用做参数或做返回值，减少了拷贝，提高了程序的效率。当我们把s1 move处理以后, 会被当成右值，所以构造s3时调用的是移动构造，但是这里要注意，一般是不要这样用的，因为我们会发现s1的资源被转移给了s3，s1被置空了。
初识C++之左值引用与右值引用
Masquerena114514的博客
04-26 2388
本文介绍了C++中的左值引用和右值引用的概念、作用和使用场景使用方法
C++ | 左值引用 与 右值引用
专注于C/C++/Linux领域创作
02-01 92
（参看自博客：【译】VC10中的C++0x特性 part 1：Lambdas，auto，以及 static_assert） 用 & 声明的引用类型被称作 lvalue 引用，而用 && 声明的引用类型被称作 rvalue 引用。 （“lvalue ”，即“Left value” 左值； “rvalue ”，即“Right value” 右值。） 两条规则： 遵守 const 正确性，所以不能把非常量引用绑定到常量上。 避免意外修改临时对象，所以不能把非常量 lvalue 引用绑定到
C++左值、右值、左值引用、右值引用的详解
咸鱼爱幻想的博客
03-11 726
左值是可以放在赋值号左边可以被赋值的值；左值必须要在内存中有实体；右值当在赋值号右边取出值赋给其他变量的值；右值可以在内存也可以在CPU寄存器。一个对象被用作右值时，使用的是它的内容(值)，被当作左值时，使用的是它的地址。
c++ | 左值引用 & 右值引用
qq_42278275的博客
08-09 431
1、替代需要销毁对象的拷贝，提高效率：某些情况下，需要拷贝一个对象然后将其销毁，如：临时类对象的拷贝就要先将旧内存的资源拷贝到新内存，然后释放旧内存，引入右值引用后，就可以让新对象直接使用旧内存并且销毁原对象，这样就减少了内存和运算资源的使用，从而提高了运行效率；注意：c不可以引用 const a*3，const c 可以引用 const a*3，但是有无const的 a 都不行！注意：b不可以引用const a，但const b 可以引用 const a，也可以a*3, 也可以const a*3。....
左值、右值、将亡值 | 左值引用、右值引用
kiev087的博客
09-18 400
关于左值、右值、将亡值和左值引用、右值引用的介绍和注意事项
C++ 左值引用和右值引用
weixin_51795597的博客
02-02 1169
1、引用是别名2、声明时必须初始化3、通过引用修改变量4、引用的本质是指针常量三、区分左值和右值1、左值可以在等号左边，能够取地址，具名；比如变量名、返回左值引用的函数调用、前置自增/自减、赋值运算符、解引用等2、右值只能在等号右边，不能取地址，不具名；右值分为纯右值和将亡值，纯右值比如字面值、返回非引用类型的函数调用、后置自增/自减等1、将亡值是C++11引入的一种新的引用类型，用于支持移动语义的实现；2、在C++中，表达式具有值的属性，可以分为左值和右值。
31_c++中的左值引用与右值引用1
08-03
左值：可以取地址的，有名字的，临时的右值：不能取地址的，没有名字的，临时的举个栗： int a = b + c ，a 就是左值，其变量名为 a ，通过 &a 可
浅谈C++左值引用和右值引用
08-31
下面小编就为大家带来一篇浅谈C++左值引用和右值引用。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C++11中的左值引用和右值引用
12-22
1.首先区分左值和右值 　左值是表达式结束后依然存在的持久对象 　右值是表达式结束时不再存在的临时对象 　便捷方法：对表达式取地址，如果能，则为左值，否则为右值 　举例： 　int a = 10 　int b = 20 　...
C++11右值引用和转发型引用教程详解
01-21
右值引用采用T&&这一语法形式，比传统的引用T&（如今被称作左值引用 lvalue reference）多一个&。 如果把经由T&&这一语法形式所产生的引用类型都叫做右值引用，那么这种广义的右值引用又可分为以下三种类型： ...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 980
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 134
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 658
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1093
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 271
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
c++ 左值引用和右值引用
09-13
c++中的左值引用（lvalue reference）和右值引用（rvalue reference）是用来处理对象所有权的概念。 左值引用是对一个对象的别名，可以对其进行赋值和修改操作。而右值引用是对一个临时对象或即将被销毁的对象的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值