C++之移动语义与左值右值深入学习：从入门到精通！

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

简介

本文详细阐述了 C++ 中关于移动语义、左值右值等技术的基本概念和常用技巧。

问题的产生

每一项技术的诞生都是为了解决某一个问题，移动语义、左值右值也是一样，因此我们先来看看问题产生的背景。

先来看一段代码：

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

#pragma warning(disable:4996)

using namespace std;

class String {
public:
	String() :_pstr(nullptr) {
		cout << "无参构造String()" << endl;
	}

	String(const char* pstr) : _pstr(new char[strlen(pstr) + 1]()) {
		cout << "C风格字符串构造 String(const char* )" << endl;
		strcpy(_pstr, pstr);
	}

	String(const String& rhs):_pstr(new char[strlen(rhs._pstr)+1]()) {
		cout << "拷贝构造 String(const String &)" << endl;
	}

	String& operator=(const String& rhs) {
		cout << "拷贝赋值运算符函数String& operator=(const String&)" << endl;
		if (this != &rhs) { //1、防止自复制
			delete[] _pstr; //2、释放左操作数
			_pstr = nullptr;
			//深拷贝
			_pstr = new char[strlen(rhs._pstr) + 1]();
			strcpy(_pstr, rhs._pstr);
		}
		return *this;
	}

	~String() {
		cout << "~String()" << endl;
		if (_pstr) {
			delete[] _pstr;
			_pstr = nullptr;
		}
	}

	friend ostream& operator<<(ostream& os, const String& rhs);
private:
	char* _pstr;
};

ostream& operator<<(ostream& os, const String& rhs) {
	if (rhs._pstr) {
		os << rhs._pstr;
	}
	return os;
}

void test() {
	// 会调用含 const char* 参数的构造函数
	String s1("hello");
	cout << "s1 = " << s1 << endl;

	cout << endl;

	// 会调用拷贝构造函数
	String s2 = s1;
	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;

	cout << endl;

	// 从结果上看，好像是调用 const char* 参数的构造函数？
	String s3 = "world";
	cout << "s3 = " << s3 << endl;
}

int main() {
	test();
	return 0;
}

运行结果：

在这里插入图片描述

从运行结果上看，貌似 s1 和 s3 这两种初始化方式都调用的是 C 风格字符串参数的构造函数：

String s1("hello");
String s3 = "world";

但是实际上，String s3 = "world"; 这行代码本应该是和 s1 调用不一样的构造函数，为什么？

因为 "world" 属于一个 C 风格的字符串，而 s3 可以看作是一个 C++ 风格的字符串。

从 C 风格字符串向 C++ 风格字符串进行赋值这个行为如果能执行的话，其背后一定会有个隐式类型转换的操作，因为转换的时候只能是同种类型之间的转换。

因此下面这行代码的行为：

String s3 = "world";

实际上背后还执行了一步：

String("world");

而 s1 则是直接调用了对应的构造函数完成初始化：

String s1("hello");// s1 直接调用 String(const char*) 构造函数完成初始化了

因此对于 s3 来说，它先将 “world” 转换成了 String(“world”) 这个临时对象，然后再从 String(“world”) 这个临时对象又转换成了实际的对象 s3 。

正因为转换过程中产生了 String(“world”) 这个临时对象，因此其会调用一次含 C 风格字符串参数的构造函数一次，所以最后从运行结果上来看，似乎 s1 和 s3 的初始化过程相同，看起来好像都是通过含 C 风格字符串参数的构造函数完成对象初始化的。

实际上，在临时对象转换为 s3 对象这个过程，会调用一次拷贝构造函数，又因为这是个临时对象，被临时创建完之后就会立马被销毁，那么自然而然就会调用一次析构函数，但是因为现在的编译器给我们做了编译优化导致最后的运行结果中没有出现这个现象。

不过通过一些编译指令我们还是可以人为的看到这个现象：

在这里插入图片描述

对比两次的编译结果，不难发现上面多了一次拷贝构造的调用以及一次析构函数的调用。

最后可以得出一个结论，String("world") 属于一个右值或者说一个临时对象，它的生命周期就只在这一行代码中：

String s3 = "world";

由此不难发现，这多出来的一次拷贝构造和析构函数的调用并没有多大意义（因为只是临时的，创建完之后立马就会销毁），相反还会浪费资源和时间，会让程序执行的效率降低。

因此对于这种情况，实际上我们是可以做相应的处理的，怎么做？

如果说我们能去将相应的右值能够识别出来，那么这个右值里所涉及到的内存空间我们就不让它销毁而直接赋值给我们的 s3，那么这个时候问题就解决了。

具体的说，临时对象 String("world") 的创建是没有问题的也是肯定得创建的，它会去正常的申请堆内存空间，但这个时候如果说我们能够有一种语法规则能把该临时对象给识别出来然后把该临时对象所申请的堆内存空间直接转给我们的 s3，那么这个时候 s3 去进行创建的时候就不会需要再 new 一次了，问题也就圆满解决了。

那么如何区分出右值呢？这就要进入到我们的下一节内容了。

左值与右值的区分

直接上代码：

#include <iostream>
#include <string>
using namespace std;

void test() {
	int a = 10;
	int b = 20;
	
	//不难发现，对于 a 和 b ，我们都是可以正常取地址的
	//因此此时的 a 和 b 就都是左值
	&a;
	&b;
	
	//我们使用指针变量，发现对于指针变量 pflag 也可以取地址
	//因此 pflag 也是左值
	int* pflag = &a;
	&pflag;
	&*pflag;
	
	//对于string类型，也可以用类似的方法测试
	//不难发现一样是可以取地址的，因此 s1 和 s2 也是左值
	string s1 = "hello";
	string s2 = "world";
	&s1;
	&s2;
	
	//对于自增的情况
	&(++a); //正确
	//&(a++); 报错，因为后置++这个过程返回的是一个临时对象，无法取地址，因此是右值
	
	//对于表达式的情况
	//&(a + b); 报错，是一个右值
}

int main() {
	test();
	return 0;
}

由上述代码不难推知，在 C++ 中，左值和右值的区别就是左值是可以取地址的，而右值不可以。

另外引用相关的概念也与左值右值有关联，我们也来看一下，依然是看代码：

#include <iostream>
#include <string>
using namespace std;

void test() {
	int a = 10;
	int b = 20;
	
	//对 ref 取地址是 ok 的
	const int& ref = a; //const左值引用可以绑定到左值
	&ref;
	// int& ref1 = 10; 报错，左值引用不可以绑定到右值上
	const int& ref1 = 10; //但const左值引用可以绑定到右值上
	//这也是为什么我们的拷贝构造函数的参数必须要写成const左值引用的原因
	//因为这样不管传的是左值还是右值进入拷贝构造函数就都是ok的
}

int main() {
	test();
	return 0;
}

因为 10 不能被取地址，因此上面的代码注释中将其也归入了右值一列，但它其实还有个名字，叫做字面值常量。

因此简单的对左值和右值进行分类的话大致如下：

左值：可以取地址。

右值：不能进行取地址。包括临时变量、临时对象、字面值常量。

但依据上面的内容，我们现在也只能做到把左值给区分出来，而没办法有效区分出右值。

区分左值的话我们只需要使用左值引用即可：

在这里插入图片描述

而 const 左值引用既可以绑定到左值又可以绑定到右值，因此其也是区分不出来右值的。

因此现在我们需要一种新的语法手段，来将右值给区分出来。

右值引用的概念

这个语法就是右值引用，看代码：

#include <iostream>
#include <string>
using namespace std;

void test() {
	//&&表示右值引用，这是C++11标准提出来的
	//使用右值引用，发现可以绑定到右值上
	int&& rref = 10;
	//那么右值引用可以绑定到左值上面吗？
	int a = 10;
	//int&& rref = a; 报错，说明右值引用无法绑定到左值上
}

int main() {
	test();
	return 0;
}

通过上面的代码，说明了通过右值引用此时我们可以有效地区分出右值了。

右值引用可以识别右值，但不能识别左值。

这就意味着如果我们将原来的拷贝构造函数的左值引用给换成右值引用的话，那么在传进一个右值的时候应该就会调用这个有右值引用的 “拷贝构造函数” 了吧？

移动构造函数

当然！

依然是之前的 String 例子的代码，如下所示：

String(String&& rhs){
	cout << "右值引用的拷贝构造 String(const String &&)" << endl;
}

那么此时当我们再执行程序到下面这一行时：

String s3 = "world";

之前我们说过这行代码会产生一个临时对象，为了避免效率降低我们提出的方法是让这个临时对象申请的堆空间资源不要销毁，而是直接转给 s3，这样就能有效提升效率，那么这个右值引用的拷贝构造函数要做的就应该是这么一件事情，我们来实现一下：

//在执行 String s3 = String("world");的时候调用下面的右值拷贝构造
//直接将传进来的 _pstr 转给 s3
//_pstr是s3的成员变量，rhs._pstr是临时对象的成员变量
//此时进行浅拷贝，将s3的_pstr指向了临时对象所申请的内存空间
//此时s3就不需要再次申请空间，就解决了我们之前提出的问题
String(String&& rhs):_pstr(rhs._pstr) {
	cout << "右值引用的拷贝构造 String(const String &&)" << endl;
	//这里还要做一步，为了防止临时对象被销毁时调用delete造成二次析构
	//因此这里需要将临时对象的指针置为空
	rhs._pstr = nullptr;
}

而这就是我们一直在说的移动语义，而我们一直说的右值形式的构造函数其正名为：移动构造函数。

“ 移动 ” 二字的意思以上面的例子就是说将临时对象 String(“world”) 申请的堆空间直接转移给 s3 对象的数据成员 _pstr 了。

完整的代码如下：

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

#pragma warning(disable:4996)

using namespace std;

class String {
public:
	String() :_pstr(nullptr) {
		cout << "无参构造String()" << endl;
	}

	String(const char* pstr) : _pstr(new char[strlen(pstr) + 1]()) {
		cout << "C风格字符串构造 String(const char* )" << endl;
		strcpy(_pstr, pstr);
	}

	String(const String& rhs):_pstr(new char[strlen(rhs._pstr)+1]()) {
		cout << "拷贝构造 String(const String &)" << endl;
		strcpy(_pstr, rhs._pstr);
	}
	
	//移动构造函数
	//在执行 String s3 = String("world");的时候调用下面的右值拷贝构造
	//直接将传进来的 _pstr 转给 s3
	//_pstr是s3的成员变量，rhs._pstr是临时对象的成员变量
	//此时进行浅拷贝，将s3的_pstr指向了临时对象所申请的内存空间
	//此时s3就不需要再次申请空间，就解决了我们之前提出的问题
	String(String&& rhs):_pstr(rhs._pstr) {
		cout << "右值引用的拷贝构造 String(const String &&)" << endl;
		//这里还要做一步，为了防止临时对象被销毁时调用delete造成二次析构
		//因此这里需要将临时对象的指针置为空
		rhs._pstr = nullptr;
	}

	String& operator=(const String& rhs) {
		cout << "拷贝赋值运算符函数String& operator=(const String&)" << endl;
		if (this != &rhs) { //1、防止自复制
			delete[] _pstr; //2、释放左操作数
			_pstr = nullptr;
			//深拷贝
			_pstr = new char[strlen(rhs._pstr) + 1]();
			strcpy(_pstr, rhs._pstr);
		}
		return *this;
	}

	~String() {
		cout << "~String()" << endl;
		if (_pstr) {
			delete[] _pstr;
			_pstr = nullptr;
		}
	}

	friend ostream& operator<<(ostream& os, const String& rhs);
private:
	char* _pstr;
};

ostream& operator<<(ostream& os, const String& rhs) {
	if (rhs._pstr) {
		os << rhs._pstr;
	}
	return os;
}

void test() {
	// 会调用含 const char* 参数的构造函数
	String s1("hello");
	cout << "s1 = " << s1 << endl;

	cout << endl;

	// 会调用拷贝构造函数
	String s2 = s1;
	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;

	cout << endl;

	// 从结果上看，好像是调用 const char* 参数的构造函数？
	String s3 = "world";
	cout << "s3 = " << s3 << endl;
}

int main() {
	test();
	return 0;
}

此时再编译运行，可以发现已经达到了我们要的效果（注意去掉编译器优化嗷）：

在这里插入图片描述

最后注意：针对于右值而言，移动构造函数优先于拷贝构造函数的执行。

移动赋值运算符函数

同样的道理，我们的赋值运算符函数也存在这样的移动语义的问题。

来看代码：

//省略其它代码

void test() {
	// 会调用含 const char* 参数的构造函数
	String s1("hello");
	cout << "s1 = " << s1 << endl;

	cout << endl;

	// 会调用拷贝构造函数
	String s2 = s1;
	cout << "s1 = " << s1 << endl;
	cout << "s2 = " << s2 << endl;
	
	//调用赋值运算符函数
	cout << endl;
	s2 = String("world");
	cout << "s2 = " << s2 << endl;
}

int main() {
	test();
	return 0;
}

运行结果如下：

在这里插入图片描述

可以发现在进行赋值运算的时候也存在这样关于移动语义的问题，解决方法也是一样的。

根据之前的经验，我们可以写出移动赋值运算符函数如下：

//在执行 s2 = String("world"); 时就会调用下面这个移动赋值运算符函数了
String& operator=(String&& rhs) {
	cout << "移动赋值运算符函数String& operator=(const String&&)" << endl;
	//虽然右值没办法取地址
	//但是右值引用在作为函数形参的情况下是可以取地址的（函数的形参都是左值）
	//因为右值引用在作为函数形参时本身是可以绑定到某个右值上的
	//这意味着这里的右值引用是个左值（后面会举例子什么时候右值引用其实是个右值）
	//因此下面的 &rhs 成立
	if (this != &rhs) { //1、防止自复制
		delete[] _pstr; //2、释放左操作数
		_pstr = nullptr;
		//浅拷贝
		_pstr = rhs._pstr;
		rhs._pstr = nullptr;
	}
	return *this;
}

此时运行结果：

在这里插入图片描述

可以看到移动赋值运算符函数被调用了，这就印证了我们的想法。

std::move() 的使用

在上面的移动赋值运算符函数中：

//在执行 s2 = String("world"); 时就会调用下面这个移动赋值运算符函数了
String& operator=(String&& rhs) {
	cout << "移动赋值运算符函数String& operator=(const String&&)" << endl;
	//虽然右值没办法取地址
	//但是右值引用在作为函数形参的情况下是可以取地址的（函数的形参都是左值）
	//因为右值引用在作为函数形参时本身是可以绑定到某个右值上的
	//这意味着这里的右值引用是个左值（后面会举例子什么时候右值引用其实是个右值）
	//因此下面的 &rhs 成立
	if (this != &rhs) { //1、防止自复制
		delete[] _pstr; //2、释放左操作数
		_pstr = nullptr;
		//浅拷贝
		_pstr = rhs._pstr;
		rhs._pstr = nullptr;
	}
	return *this;
}

乍一看貌似好像这个防止自复制的操作是多余的，其实不然，因为在 C++ 中有一个函数可以将左值变成右值，它就是 std::move() 。

因此如果不考虑自复制的情况的话，当有下面代码的时候：

s2 = std::move(s2);

此时就一定会出问题了，因此防止自复制这一步一定不能省嗷。

std::move() 的作用就是将左值转换为右值，表明不想再使用该左值了。

这个转换的过程实际上在底层中就是发生了一次强制转换 static_cast<T &&> (lvalue) 而已。

一点点细节补充

为什么右值引用不考虑 const

因为没有意义啊，右值引用引用的都是右值，而我们拿到右值都是要修改的，比如上面代码我们要将临时对象的指针置空，加上 const 反而无法执行置空操作了。另外对于比如字面值常量等右值而言，它本来就是没办法改变的，加上 const 虽然不报错但是也没有什么额外的收益：

const int&& ref = 10;

因此对于右值引用我们一般不会考虑 const 的情况。

拷贝控制语义与移动语义的概念

拷贝构造函数与赋值运算符函数，编译器会自动提供；但是移动构造函数与移动赋值运算符函数，编译器不会自动提供，必须要手写。

将拷贝构造函数与赋值运算符函数称为具有拷贝控制语义的函数；将移动构造函数与移动赋值运算符函数称为具有移动语义的函数。

最后，移动语义函数的调用优先级要高于拷贝语义的函数。

总结

综上所述，我们所谓的移动语义呢其实指的就是类里面所具有的两个函数：一个叫做移动构造函数，一个叫做移动赋值运算符函数。这样当我们传递进来的是右值的时候我们就不必要再去执行深拷贝而只要去执行浅拷贝即可。

最后再简要总结一下本文的内容：

在这里插入图片描述

在地球迷路的怪兽
关注
专栏目录
C++左值，右值，std::move，移动构造函数
qq_66157971的博客
08-13 754
在有必要的情况下尽量添加移动构造函数和移动构造赋值运算符，达到减少拷贝构造和赋值运算的目的，当然，一般只有在new分配了大量内存的这种类才需要移动构造函数和移动赋值运算符。不抛出异常的移动构造函数、移动赋值运算符都应该加上关键字noexcept。一个本该调用移动构造函数和移动赋值运算符的地方，如果类中没有提供，系统会调用拷贝构造函数和拷贝赋值运算符代替。
std::move和左值右值
就是那个党伟
05-29 530
首先，函数参数T&&是一个指向模板类型参数的右值引用，通过引用折叠，此参数可以与任何类型的实参匹配（可以传递左值或右值，这是std::move主要使用的两种场景)。在 C++ 中，左值是可以被取地址的表达式，而右值是临时的、不可取地址的表达式。通常，左值是具有名称、有持久性的，而右值是临时性的、瞬时的。std::move 是 C++ 标准库中的一个函数模板，用于将一个左值（左值引用）转化为右值引用，从而实现移动语义。一个对象被用作右值时，使用的是它的内容(值)，被当作左值时，使用的是它的地址。
C++左值与右值以及std::move详解
weixin_44537992的博客
05-21 932
1、左值与右值 左值可以取地址，右值不可取地址 左值具名，对应指定内存域，可访问；右值不具名，不对应内存域，不可访问。临时对像是右值。左值可处于等号左边，右值只能放在等号右边。区分表达式的左右值属性有一个简便方法：若可对表达式用 & 符取址，则为左值，否则为右值。 左值可以在等号右边，可以在左边，但是右值必须在等号右边 int a; a = 1; // here, a is an ...
详解 C++ 左值、右值、左值引用以及右值引用
热门推荐
Butayarou的博客
07-25 1万+
主要讲解了 C++11 的右值引用（及其支持的移动语义和完美转发）。
C++中左值 右值 左值引用 右值引用 移动语义
Electic_pupil的博客
03-23 248
c++中，很多情况下不需要或者不想把一个对象从一个地方复制到另一个地方。例如：如果把一个对象传递给一个函数，函数需要获得对象的所有权，不得不执行拷贝。左值是存储在内存单元中的，有具体的地址可寻；而右值临时变量，字面常量，没有固定的存储单元，用完即消亡。我们希望直接利用该字符串常量初始化对象，所以重载一个右值引用的构造函数，即上述代码中的注释部分。此时如果有一个常量左值引用的函数重载，和右值引用的函数重载，编译器会优先调用右值引用的函数重载。不能用左值引用去引用右值，但是可以用常量左值引用去引用右值。
C++——左值与右值、右值引用、移动语义与完美转发
Aaron_1997的博客
03-22 1853
C++——左值与右值、右值引用、移动语义与完美转发 在C++或者C语言中，一个表达式（可以是字面量、变量、对象、函数的返回值等）根据其使用场景不同，分为左值表达式和右值表达式。 一、左值和右值的定义 左值的英文为locator value，简写为lvalue，可意为存储在内存中、有明确存储地址（可寻址）的数据 右值的英文为read value，简写为rvalue，指的是那些可以提供数据值的数据（不一定可寻址，例如存储与寄存器中的数据） 二、如何判断一个表达式是左值还是右值（大多数场景） 可位
C++易被忽略的知识点：移动语义 & 左值右值
Tyler_Zx的博客
06-03 6329
lvalue 和 rvalue 每个表达式都会得到 lvalue 或 rvalue。它们的区别是，lvalue是一个持久存在的值，其内存地址可被用来持续存储值；rvalue是一个暂时存储的结果。之所以称为 lvalue，是因为得到 lvalue 的表达式通常出现在赋值运算符的左边，而 rvalue 只能出现在赋值运算符的右边。表达式的结果不是 lvalue，就是 rvalue。包含一个变量名称的表达式总是 lvalue。 注意：虽然名称中带有 value，但是 lvalue 和 rvalue 是表达式分
【C++ 】【move 、移动语义】左值、右值；左值引用、右值引用；移动语义；move的使用；实现资源让渡；配合unique_ptr；
多丰富下自己呀
05-05 1072
系列文章目录 提示： 文章目录系列文章目录前言一、左值/右值？1.1 定义1.2 右值能修改吗？二、左值引用/右值引用？2.1引入右值引用2.2 引入右值引用的意义/目的三、move/forward？//待更新参考 前言 提 一、左值/右值？ 1.1 定义 左值与右值（lvalue/rvalue）这两概念是从 c 中传承而来的。 在 c 中，左值指的是既能够出现在等号左边也能出现在等号右边的变量(或表达式)。 右值指的则是只能出现在等号右边的变量(或表达式)。 右值不能当成左值使用，但左值可以当成右值使
C++ 左值右值 || std::move() || 浅拷贝，深拷贝 || 数据类型
sengyongan的博客
06-25 758
【代码】左值右值 || std::move() || 浅拷贝，深拷贝 || 数据类型。
C++ 移动语义 (左值右值 移动构造/赋值函数 move强制移动)
夢裡夢到醒不來的夢
05-23 407
什么是移动语义 移动语义是C++11新增的特性，利用移动语义可以做到移动一个对象而不是拷贝对象。 一般用于处理临时对象的赋值，例如： vector<int> f(const vector<int> &arr) { vector<int> tmp; for(int i=0;i<arr.size();i++) tmp.push_back(arr[i]+233); } ...
c_cpp_properties.json文件的作用
程序员黄老师的精品课！
10-10 226
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
大话C++：第15篇 友元
whccf的博客
10-09 953
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
第一节、C语言概览
lopowh的博客
10-13 169
C语言中格式化输出函数为printf（），它用来输出数据到计算机屏幕或文件中。程序语言一般都是由关键字，标识符和其他语法单位组成。Printf("，")；Scanf("",)用来从标准输入设备（键盘）读取输入的信息。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 979
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
C++的随机数操作
lch_001的博客
10-13 103
如果不引入种子，它的随机数不是随机数，是固定的一串数字。首先想到的肯定是rand()函数，但是这个有点问题。srand()函数，产生随机的种子。引入头文件<stdlib.h>产生0-99的随机数。
[C++ 核心编程]笔记 4.1.2 struct和class的区别
最新发布
qq_42995393的博客
10-13 149
在C++中 struct和class唯一的区别就在于 默认的访问权限不同。
c语言：二叉树的创建、前序遍历、中序遍历、后续遍历
Narnat的博客
10-08 403
代码中创建的二叉树如下图。
C++深入理解：左值与右值解析
左值和右值的概念是C++语法规则的基础，对编译器优化和现代C++特性如移动语义的理解至关重要。 左值（lvalue）在C++中是指能够出现在赋值操作符左侧的表达式，它代表了一个可以被读取和修改的对象。例如，变量就是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在地球迷路的怪兽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值