543-理解C++的右值引用并进行应用(CMyStirng）

最新推荐文章于 2022-12-05 23:47:47 发布
最新推荐文章于 2022-12-05 23:47:47 发布
阅读量311 收藏 5
点赞数 1
分类专栏： C++的学习 文章标签： c++ 右值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LINZEYU666/article/details/120236488
版权
本文分析了C++中右值引用在CMyString类中的应用，如何通过右值引用优化拷贝构造函数和赋值运算符，避免不必要的内存开销和数据拷贝。讲解了右值引用的特性，以及在vector中的应用，展示了如何使用std::forward进行类型完美转发，以提高代码效率。同时，讨论了move和forward在内存管理中的作用，特别是在容器如vector的push_back操作中的效率提升。
摘要由CSDN通过智能技术生成

CMyStirng代码的问题分析

class CMyString
{
public:
	CMyString(const char *str = nullptr)
	{
		cout << "CMyString(const char*)" << endl;
		if (str != nullptr)
		{
			mptr = new char[strlen(str) + 1];
			strcpy(mptr, str);
		}
		else
		{
			mptr = new char[1];
			*mptr = '\0';
		}
	}
	~CMyString()
	{
		cout << "~CMyString" << endl;
		delete[]mptr;
		mptr = nullptr;
	}
	//带左值引用参数的拷贝构造
	CMyString(const CMyString &str)
	{
		cout << "CMyString(const CMyString&)" << endl;
		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
	}

	//带左值引用参数的赋值重载函数
	CMyString& operator=(const CMyString &str)
	{
		cout << "operator=(const CMyString&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
		return *this;
	}

	const char* c_str()const { return mptr; }
private:
	char *mptr;

};

在这里插入图片描述
由于问题场景的特殊，子函数调用时我们无法返回一个临时对象。
而且我们也只能用赋值的方式接收一个函数调用的返回值。

我们来分析分析上面的代码
1、首先，str1和str2都是调用普通构造函数。
实参str1到形参str是引用的方式接收，没有产生构造。
2、然后普通构造tmpStr局部对象。 tmpStr这个对象占4个字节，有一个char*指针，指向外部的一个new出来的堆内存，堆内存存放的是字符串。

然后return tmpStr；tmpStr是局部对象，3、只能调用拷贝构造函数，在这里插入图片描述
构建一个新的对象，在这里插入图片描述
4、tmpStr拷贝构造新对象，然后调用析构函数析构tmpStr对象，这样就白耗费资源了，tmpStr资源不要就早说，直接给函数栈帧上的对象就好啦。
在这里插入图片描述
我们想要拷贝构造函数做这个事情：
就完全没有内存开辟，内存释放和数据拷贝了。
在这里插入图片描述
这是我们的目的，但是不能这样改，不然正常的拷贝构造函数就没法做了

接下来我们再看第二个问题
在这里插入图片描述
用临时量给str2赋值，str2是原本已经存在的对象，它也有一个指针mptr，原先也指向了一个空间。
对于赋值来说，排除自赋值，然后把原先指向的空间释放掉，然后按照str的尺寸开辟空间，然后拷贝数据进行来。即按照临时对象的字符串大小开辟空间，然后把数据一个一个拷贝进来。
在这里插入图片描述
然后出语句，把这个临时对象析构及它指向的堆内存空间释放掉。
瞎折腾！直接把临时对象的外部资源给str2不就完了吗？
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

复习一下右值引用

int main()
{
	//右值引用
	int a = 10;
	int &b = a;//左值：有内存、有名字  右值：没名字（临时量）或没内存
	//int &&c = a;//无法将左值绑定到右值引用
    
    //int &c = 20;//不能用左值引用绑定一个右值
    
	/*
	int tmp = 20;
	const int &c = tmp; 通过这个c不可以改临时量的值 
	*/
	const int &c = 20;//可以！ 
	
	/*
	int tmp = 20;
	int &&d = tmp; 通过这个d是可以改临时量的值 
	*/
	int &&d = 20;//可以把一个右值绑定到一个右值引用上
	
	//C++11把临时量都当做右值处理 
	CMyString &&e = CMyString("aaa");//可以！ 
    const CMyString &e = CMyString("aaa");//可以！
	 
	int &f = d;//一个右值引用变量，本身是一个左值，d：有内存有名字

	return 0;
}

用右值引用优化CMyStirng代码

class CMyString
{
public:
	CMyString(const char *str = nullptr)
	{
		cout << "CMyString(const char*)" << endl;
		if (str != nullptr)
		{
			mptr = new char[strlen(str) + 1];
			strcpy(mptr, str);
		}
		else
		{
			mptr = new char[1];
			*mptr = '\0';
		}
	}
	~CMyString()
	{
		cout << "~CMyString" << endl;
		delete[]mptr;
		mptr = nullptr;
	}
	//带左值引用参数的拷贝构造
	CMyString(const CMyString &str)
	{
		cout << "CMyString(const CMyString&)" << endl;
		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
	}
	//带右值引用参数的拷贝构造
	CMyString(CMyString &&str)//str引用的就是一个临时对象
	{
		cout << "CMyString(CMyString&&)" << endl;
		mptr = str.mptr;
		str.mptr = nullptr;
	}
	//带左值引用参数的赋值重载函数
	CMyString& operator=(const CMyString &str)
	{
		cout << "operator=(const CMyString&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
		return *this;
	}
	//带右值引用参数的赋值重载函数
	CMyString& operator=(CMyString &&str)//str引用的是临时对象
	{
		cout << "operator=(CMyString&&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = str.mptr;
		str.mptr = nullptr;
		return *this;
	}
	const char* c_str()const { return mptr; }
private:
	char *mptr;

	friend CMyString operator+(const CMyString &lhs,
		const CMyString &rhs);
	friend ostream& operator<<(ostream &out, const CMyString &str);
};

CMyString operator+(const CMyString &lhs,
	const CMyString &rhs)
{
	//char *ptmp = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
	CMyString tmpStr;
	tmpStr.mptr = new char[strlen(lhs.mptr) + strlen(rhs.mptr) + 1];
	strcpy(tmpStr.mptr, lhs.mptr);
	strcat(tmpStr.mptr, rhs.mptr);
	//delete []ptmp;
	return tmpStr;//直接调用右值拷贝构造函数
	//return CMyString(ptmp);
}
ostream& operator<<(ostream &out, const CMyString &str)
{
	out << str.mptr;
	return out;
}

在这里插入图片描述
在这里插入图片描述

示意图如下：
在这里插入图片描述

在这里插入图片描述
同样的代码，我们运行一下
在这里插入图片描述
没有任何内存的开辟和释放和数据的拷贝

CMyStirng在vector上的应用

在这里插入图片描述

在这里插入图片描述

这两个push_back是调用的是普通的拷贝构造函数还是右值的拷贝构造函数？
在这里插入图片描述

int main()
{
	CMyString str1 = "aaa";//普通构造 

	vector<CMyString> vec;
	vec.reserve(10);

	cout << "-----------------------" << endl;
	vec.push_back(str1);//在底层数组上拷贝构造一个新对象 
	vec.push_back(CMyString("bbb"));//先进行临时对象的构造，然后调用右值拷贝构造，把资源直接给vector底层 
	cout << "-----------------------" << endl;

	return 0;
}

move和forward

剖析并完成push_back方法
引用重叠：
左值引用+右值引用=左值引用
右值引用+右值引用=右值引用
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一个模板可以代替下面这2个函数
但是模板函数中调用construct传入的val还是一个左值啊！怎么区分左值右值引用调用？
在这里插入图片描述
在模板函数调用construct中引入std::forward
可以返回val到底是左值还是右值
forward:类型完美转发，能够识别左值和右值类型
可以根据参数val本身的定义识别出val是左值还是右值。如果val是左值类型它就会返回左值类型，调用construct的左值引用的函数。如果val是右值类型，它就返回右值类型，调用construct的右值引用的函数。
在这里插入图片描述
forward是通过模板的非完全特例化实现的。
move(左值)：移动语义，得到右值类型 (int&&)a

#include <iostream>
#include <vector>
using namespace std;
 
template<typename T>
struct Allocator
{
	T* allocate(size_t size)//负责内存开辟
	{
		return (T*)malloc(sizeof(T) * size);
	}
	void deallocate(void *p)//负责内存释放
	{
		free(p);
	}
	/*void construct(T *p, const T &val)//负责对象构造
	{
		new (p) T(val); // 定位new
	}
	void construct(T *p, T &&val)//负责责对象构造
	{
		new (p) T(std::move(val));
		//定位new 强转成右值引用类型 调用底层的CMyString的右值引用的拷贝构造函数 
	}*/
	
	//可以用std::move强转成右值，也可以如下做法： 
	//无法区分右值和左值的简便的解决办法： 
	template<typename Ty>
	void construct(T *p, Ty &&val)
	{
		new (p) T(std::forward<Ty>(val));
	}
	void destroy(T *p)//负责对象析构
	{
		p->~T();// ~T()代表了T类型的析构函数
	}
};

/*
容器底层内存开辟，内存释放，对象构造和析构，都通过allocator空间配置器来实现
*/
template<typename T, typename Alloc = Allocator<T>>
class vector
{
public:
	vector(int size = 10)//构造函数 
	{
		//需要把内存开辟和对象构造分开处理
		//_first = new T[size];
		_first = _allocator.allocate(size);
		_last = _first;
		_end = _first + size;
	}
	~vector()//析构函数 
	{
		//析构容器有效的元素，然后释放_first指针指向的堆内存
		//delete[]_first;
		for (T *p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);//释放堆上的数组内存
		_first = _last = _end = nullptr;
	}
	vector(const vector<T> &rhs)//拷贝构造函数 
	{
		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
	}
	vector<T>& operator=(const vector<T> &rhs)//赋值函数 
	{
		if (this == &rhs)
			return *this;

		//delete[]_first;
		for (T *p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);

		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}
	void pop_back()//从容器末尾删除元素
	{
		if (empty())
			return;
		//--_last; //不仅要把_last指针--，还需要析构删除的元素
		--_last;
		_allocator.destroy(_last);
	}
	T back()const//返回容器末尾的元素的值
	{
		return *(_last - 1);
	}
	bool full()const { return _last == _end; }
	bool empty()const { return _first == _last; }
	int size()const { return _last - _first; }

	//
	/*void push_back(const T &val)//接收左值
	{
		if (full())
			expand();

		_allocator.construct(_last, val);
		_last++;
	}

	void push_back(T &&val)//接收右值 一个右值引用变量本身还是一个左值
	{
		if (full())
			expand();

		_allocator.construct(_last, std::move(val));
		//val本身还是左值啊。匹配的还是左值的construct。怎么办？ 
		//使用std::move把val 强转成右值引用类型 
		_last++;
	}*/
	//void push_back(CMyString &val)
	//CMyString&& + && = void push_back(CMyString&&val)
	template<typename Ty>//函数模板的类型推演 + 引用折叠
	void push_back(Ty &&val)//Ty CMyString& + && = CMyString&
	{
		if (full())
			expand();

		//move(左值)：移动语义，得到右值类型   (int&&)a
		//forward:类型完美转发，能够识别左值和右值类型
		_allocator.construct(_last, std::forward<Ty>(val));
		_last++;
	}
private:
	T *_first;//指向数组起始的位置
	T *_last;//指向数组中有效元素的后继位置
	T *_end;//指向数组空间的后继位置
	Alloc _allocator; // 定义容器的空间配置器对象

	void expand()//容器的二倍扩容
	{
		int size = _end - _first;
		//T *ptmp = new T[2 * size];
		T *ptmp = _allocator.allocate(2 * size);
		for (int i = 0; i < size; ++i)
		{
			//ptmp[i] = _first[i];
			_allocator.construct(ptmp + i, _first[i]);
		}
		//delete[]_first;
		for (T *p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);
		_first = ptmp;
		_last = _first + size;
		_end = _first + 2 * size;
	}
};

int main()
{
	CMyString str1 = "aaa";
	vector<CMyString> vec;

	cout << "-----------------------" << endl;
	vec.push_back(std::move(str1));//CMyString&
	vec.push_back(CMyString("bbb"));//CMyString&& move  forword
	cout << "-----------------------" << endl;

	return 0;
}

在这里插入图片描述

返回容器的效率

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

class CMyString
{
public:
	CMyString(const char *str = nullptr)
	{
		cout << "CMyString(const char*)" << endl;
		if (str != nullptr)
		{
			mptr = new char[strlen(str) + 1];
			strcpy(mptr, str);
		}
		else
		{
			mptr = new char[1];
			*mptr = '\0';
		}
	}
	~CMyString()
	{
		cout << "~CMyString" << endl;
		delete[]mptr;
		mptr = nullptr;
	}
	//带左值引用参数的拷贝构造
	CMyString(const CMyString &str)
	{
		cout << "CMyString(const CMyString&)" << endl;
		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
	}
	//带右值引用参数的拷贝构造
	CMyString(CMyString &&str)
	{
		cout << "CMyString(CMyString&&)" << endl;
		mptr = str.mptr;
		str.mptr = nullptr;
	}
	//带左值引用参数的赋值重载函数
	CMyString& operator=(const CMyString &str)
	{
		cout << "operator=(const CMyString&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = new char[strlen(str.mptr) + 1];
		strcpy(mptr, str.mptr);
		return *this;
	}
	//带右值引用参数的赋值重载函数
	CMyString& operator=(CMyString &&str)//临时对象
	{
		cout << "operator=(CMyString&&)" << endl;
		if (this == &str)
			return *this;

		delete[]mptr;

		mptr = str.mptr;
		str.mptr = nullptr;
		return *this;
	}
	const char* c_str()const { return mptr; }
private:
	char *mptr;
};

vector<CMyString> GetVector()
{
	CMyString str1 = "aaa", str2 = "bbb", str3 = "ccc";
	cout << "------------------------" << endl;

	vector<CMyString> vec;
	vec.reserve(10);
	vec.push_back(std::move(str1));
	vec.push_back(std::move(str2));
	vec.push_back(std::move(str3));

	return vec;//匹配的是容器的右值引用参数的拷贝构造
}
int main()
{
	vector<CMyString> vec;
	
	vec = GetVector();//匹配的是容器的右值引用参数的赋值函数

	return 0;
}
林林林ZEYU
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据结构基础】C++中的引用类型
weixin_65334260的博客
07-12 2436
在以严蔚敏老师的《数据结构》为代表的诸多**数据结构**的书中，都出现了C++引用这一用法，所以在学习**数据结构**的过程中，有必要认识一下C++语言中的这一用法。
C++引用类型
weixin_43408582的博客
04-09 347
文章目录引用的基本使用引用的注意事项引用的本质引用做函数参数引用做函数返回值常量引用 引用的基本使用 作用： 给变量起别名 语法： 数据类型 &别名 = 原名 int main() { int a = 10; int& b = a;//数据类型 &别名 = 原名 给变量a起了一个别名b cout << "a = " << a << endl; cout << "b = " << b << endl;
C++右值引用(right value reference)实战运用
qq_42080098的博客
04-16 726
C++11之前，我们所说的引用只有左值引用（auto &a），现在我们通常使用的引用也是左值引用，但是准确一点说，C++11之后，除了左值引用(LVaule)，还有右值引用(RValue)。 一句话概况LVaule和RValue auto a = 10; //其中 a就是左值， 10就是右值 auto b = a; //其中 b是左值，a 是右值 C++11后， L-value（左值）：指可寻址的，L表示location， A value that has an address. R-value
C++ 值类型和引用类型传递示例
weixin_30621959的博客
08-15 418
// win32test.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" void swap_point(int * &a , int * &b){ int temp = *a ; *a = *b; *b = temp ; //销毁调用方指针 //a = NULL ; //b = NULL ...
c++传值，值的类型分别为地址和引用
刘明的博客
06-04 860
以两数交换情况为例： 1、传值：值的类型为int #include "stdafx.h" #include "iostream" using namespace std; void swap(int i, int j) { cout << "i的地址为：" << &i << "\t" << "j的地址为：" << &j << endl; int temp; temp = i; i =
20200214-01 C++ 右值引用 总结
01-07
右值简单而言就是一种无法被取地址，而且只是在一个小范围内临时被使用的(C++11引入) int&& a = 10; 针对右值，引申出临终值的概念 临终值：1 可以跟左值一样被取地址 2 将要释放或者移走 static_cast() 和 std::...
C++11特性-右值与右值引用
最新发布
weixin_44840658的博客
12-05 651
c11的右值及其操作、move转移函数、forward完美转发函数
深入理解c++右值引用1
08-08
在C++编程语言中，右值引用是一种特殊的引用类型，它是C++11引入的特性，目的是为了增强语言对右值的处理能力，尤其是优化对象的移动操作。...理解并正确使用左值、右值以及它们的引用是C++编程中不可或缺的知识点。
cpp代码-左值 和 右值 ---- 左值引用(就是别名) 和 右值引用
07-14
左值引用（lvalue reference）和右值引用（rvalue reference）是C++11引入的新特性，旨在提升程序性能，尤其是对于对象的移动语义。 左值（lvalue）是指可以出现在赋值运算符左侧的表达式，即可以被命名并且可以...
c++引用类型及左右值
m0_72500922的博客
11-23 114
c++引用及左右值
C++中引用类型的简单剖析
Outtch_的博客
10-10 341
前言 对于习惯使用C语言进行开发的同学们，在看到C++中出现的&符号，可能会陷入误区，因为在C语言中&符号表示了取地址符，但其实&在C++中却有着不同的意义与用途——引用。 一：引用的简介 1.1 引用概念 引用就是给已经存在的变量取了一个别名，引用和它引用的变量共用同一块内存空间。 比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。 引用的声明方法：类型& 引用变量名 = 引用实体（引用类型必须和引用实体是同种类型） 代码演示： void TestRef(){ int
C++ 返回值类型与引用类型的区别
hbrqlpf的专栏
03-21 2166
A& a(){ return *this;} 就生成了一个固定地址的指针，并把指针带给你 但A a() { return *this;}会生成一个临时对象变量，并把这个临时变量给你 这样就多了一步操作  
C++ 中真的分值类型和引用类型吗（透彻解析版）
我有明珠一颗的博客
03-28 1960
欢迎来拍砖 我认为，C++中没有一个类型是可以肯定地说是 值类型 or 引用类型 的，一切取决于你如何使用它，如果你使用指针，哪怕是int型也可以当做引用类型来用。 以上是我由思考struct类型所引发的思考的结论，接下来上代码： #include<iostream> using namespace std; struct ss{ int a; int b; ...
C++与C#中值类型与引用类型的区别
学而时习之
12-04 2165
这些天学习C#，看到里面的值类型与引用类型，例如结构是值类型，类是引用类型，然后立马想到了C++中的类，那么C++中的类是什么类型呢，哈哈，忽然间有点迷惑，上网搜了搜还真有很多小伙伴们已经晕进去了，今天就总结一下C#与C++中值类型与引用类型的区别。 其实C#中值类型与引用类型的根本区别就是变量包含的数据在哪个内存区间上，值类型在堆栈中直接包含，引用类型在堆中间接引用，例如，C#中实例化类必需要
(C/C++学习)6.数组指针和指针数组
weixin_33670786的博客
09-30 166
说明：int (*p)[4] 和 int *p[4](数组指针和指针数组),如果你是一个初学者,也许当你看到这两个名词的时候,已经懵了。其实,只要你理解了其中的含义.这两个名词对你来说会相当简单并且很有趣,下面,我们就来深入探讨一下究竟什么是数组指针,什么是指针数组。 一.指针数组 1.前面我们已经学过数组了,比如说要创建一个一维整型数组,该怎么创建呢？应该是这样的：int arr[N]...
引用类型和值类型区别
CaonimaSimida的博客
03-16 421
1.普通的数据类型，和结构体、枚举等，是值类型，赋值时，会建立一个备份，给新的变量。 2.类、对象是引用类型，赋值时，并不会新建对象的副本，而是把对象的地址给新对象名。 所以，对象名中存储的并不是完整对象的内容，只存储了找到这个对象的地址。 3.Sets（集） 3.1概念 相同类型、没有固定顺序、数值不能重复的数据集合。 3.2哈希化 Swift中，所以默认的数据类型都是可以哈希化的
值类型与引用类型的区别
qq_44252730的博客
11-12 1646
https://www.cnblogs.com/zengming/p/6037048.html#:~:text=%E5%80%BC%E7%B1%BB%E5%9E%8B%E5%8C%85%E6%8B%AC%EF%BC%9A%E6%95%B0%E5%80%BC%E7%B1%BB%E5%9E%8B%EF%BC%8C%E7%BB%93%E6%9E%84%E4%BD%93%EF%BC%8Cbool%E5%9E%8B%EF%BC%8C%E7%94%A8%E6%88%B7%E5%AE%9A%E4%B9%89%E7%9A.
右值引用总结
u010742342的博客
06-18 515
右值引用若不作为函数参数使用,基本等于滥用 2. std::vector&lt;int&gt;&amp;&amp; return_vector(void) { std::vector&lt;int&gt; tmp {1,2,3,4,5}; return std::move(tmp); } std::vector &amp;&amp;rval_ref = return_...
C++基础
Demo_Autism的博客
10-30 2048
C++基础 C++的数据类型分为基本类型、构造类型、指针类型、引用类型、空类型。 一、数据类型 1、整型(int) 整型分为 注意:所占字节与系统相关。 类型 字节 长整型(long) 8 有符号长整型(signed long) 8 无符号长整型(signed long) 8 短整型(short) 2 有符号短整型(signed short) 2 无符号短整型...
C++右值引用与CopyElision、RVO优化详解
本文主要介绍了C++中的右值引用（rvalue reference）以及相关的编译器优化技术，如Copy Elision（拷贝消隐）和Return Value Optimization（返回值优化，RVO）。右值引用是C++11引入的新特性，旨在提高代码效率，减少...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

林林林ZEYU

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

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

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

打赏作者

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

抵扣说明：

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

余额充值