String类详解（浅拷贝，深拷贝，引用计数，写时拷贝）

最新推荐文章于 2024-07-01 14:17:25 发布
最新推荐文章于 2024-07-01 14:17:25 发布
阅读量6.4k 收藏 15
点赞数 7
分类专栏： C++ C++之行
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snow_5288/article/details/52901528
版权

String类：标准库类型string类表示可变长的字符序列，定义在std中，专门用来管理字符串，下面一起看下它的重要考点。



一，浅拷贝

      所谓浅拷贝，是指原对象与拷贝对象公用一份实体，仅仅是对象名字不同而已（类似引用，即对原对象起别名），其中任何一个对象改变都会导致其他的对象也跟着它变。如下面这段代码：

//浅拷贝
class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)//字符串为空
		{
			*_pStr = '\0';
		}
		else//字符串不为空
		{
			strcpy(_pStr,pStr);
		}
	}
	String(const String& s)//拷贝构造函数
	{
		_pStr = s._pStr;
	}
	String& operator=(String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)//判断是不是自己给自己赋值
		{
			_pStr = s._pStr;
		}
		return *this;
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			delete []_pStr;
			_pStr = NULL;
		}
	}
private:
	char* _pStr;
};

void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
	Funtest();
	system("pause");
	return 0;
}

一运行你就会发现，从程序开始运行到s4创建并赋值，程序都没有问题。



再往下走，进入析构函数



根据栈空间先入后出的原则，应该先析构s4对象，可是有上图可以看到，当释放s4后，前面创建的3个对象也都成了随机值，那么再往下走会发生什么呢？


没错，程序在运行到370行是崩溃了，这是为什么呢？请看下图。


从上我们可以看出浅拷贝存在一定的问题，那么怎样对它进行改进防止一个对象被多次释放呢，你可能会这样想。


//浅拷贝(引用计数（_count作为普通成员变量）error)
class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
		,_count(0)//初值赋值为0
	{
		if(0 == *pStr)
		{
			*_pStr = '\0';
		}
		else
		{
			strcpy(_pStr,pStr);
		}
		_count++;//每创建一个对象计数器加1
	}
	String(String& s)//拷贝构造
		:_count(s._count)//将已存在的对象s的计数器赋给当前对象
	{
		_pStr = s._pStr;
		s._count++;//将原对象的计数器加1
		_count = s._count;//将原对象的计数器加1后赋值给当前对象
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			if(--_count == 0)//如果计数器为0，说明无对象指向该空间，可以释放
			{
				delete []_pStr;
				_pStr = NULL;
			}
		}
	}
	String& operator=(String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)
		{
			_pStr = s._pStr;
			s._count++;//将原对象的计数器加1
			_count = s._count;//将已存在的对象s的计数器赋给当前对象
		}
		return *this;
	}
private:
	int _count;//给一个计数器控制析构函数
	char* _pStr;
};


void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
	Funtest();
	system("pause");
	return 0;
}

用一个计数器来控制析构函数听起来好像可以解决上述问题，可实际呢，结果却是这样的。


4个对象创建后：



调用4次析构函数之后：


之后函数就返回了。


归结一下上述问题的错误:

      我们知道，这四个对象本来指向同一块空间，计数器本来都应为4，可是现在的结果却是计数器只能控制与它相邻对象的计数器，对象创建完成后，计数器并不统一。

     其次，调用4次析构函数之后，本来应该四个对象同时被释放，可是结果却是没有一个对象的计数器为0，也就是这块空间并没有被释放，内存又泄露了呗。


为了保持计数器的统一，我们决定把计数器设置为类的静态成员函数，

//浅拷贝(引用计数(_count作为静态成员变量))
class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)
		{
			*_pStr = '\0';
		}
		else
		{
			strcpy(_pStr,pStr);
		}
		_count++;
	}
	String(const String& s)//拷贝构造
	{
		_pStr = (char*)s._pStr;
		s._count = _count;
		_count++;
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			if(--_count == 0)
			{
				delete []_pStr;
				_pStr = NULL;
			}
		}
	}
	String& operator=(String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)
		{
			_pStr = s._pStr;
			s._count = _count;
			_count++;
		}
		return *this;
	}
private:
	static int _count;
	char* _pStr;
};

int String::_count = 0;

void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
	Funtest();
	system("pause");
	return 0;
}

当函数运行到创建好s4还没有对其赋值时，



再往下执行：



由上图可知，计数器虽然统一了，然而我们的代码依旧存在bug。


错误分析：

1.我们一共只创建了4个对象，可是计数器却为5，那是因为静态成员变量为所有对象共享，任何对象都可以对它进行修改，每创建一个对象我们都对计数器加1，却忽略了创建的新对象是否与已存在的对象占同一块空间

2.调用4次析构函数后，计数器值为1，导致空间又没有被释放。


吸取上面的错误教训，我们又想到了指针。

//浅拷贝(引用计数（指针实现计数）)
class String
{
public:
	String(const char* pStr = "")//构造函数
		:count(new int(0))
		,_pStr(new char[strlen(pStr)+1])
	{
		if(NULL == pStr)
	    {
			*_pStr = '\0';
		}
		else
		{
			strcpy(_pStr,pStr);
		}
		*count = 1;
	}
	String(const String& s)//拷贝构造
		:count(s.count)
	{
		_pStr = (char*)s._pStr;
		count = s.count;
		(*count)++;
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			if(--(*count) == 0)
			{
				delete[]count;//勿忘了释放计数器指针
				delete[]_pStr;
				_pStr = NULL;
				count = NULL;
			}
		}
	}
	String& operator=(String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)
		{
			_pStr = s._pStr;
			count = s.count;
			(*count)++;
		}
		return *this;
	}
private:
	int* count;
	char* _pStr;
};


void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
	Funtest();
	system("pause");
	return 0;
}
运行过程：

创建4个对象后：



给s4赋值

后：



调用4次析构函数之后：



空间被准确释放，代码写到这里，我们会满意吗？当然不，永远记住：只有更好没有最好。指针计数的缺陷：每个对象都得为它多创建一个指针，浪费空间。还有释放麻烦，很有可能我们只记得释放_pStr,却忘了释放计数器指针造成内存泄漏，得不偿失。


接下来，对浅拷贝再次进行优化。

二，写时拷贝（Copy-On-Write）：

       即写时才拷贝，以上诸多问题让我们得知浅拷贝容易出现指针悬挂的问题，但是我们可以应用引用计数但是方式来解决浅拷贝中多次析构的问题，同时写时拷贝就应运而生了。


//写时拷贝(仿照new[]实现)
class String
{
public:
	String(const char* pStr = "")//构造函数
	     :_pStr(new char[strlen(pStr) + 4 + 1])//每次多创建4个空间来存放当前地址有几个对象
	{
		if(NULL == pStr)
		{
			(*(int*)_pStr) = 1;//将前4个字节用来计数
			_pStr += 4;//指针向后偏移4个字节
			*_pStr = '\0';
		}
		else
		{
			(*(int*)_pStr) = 1;//将前4个字节用来计数
			_pStr += 4;//指针向后偏移4个字节
			strcpy(_pStr,pStr);//将pStr的内容拷贝到当前对象的_pStr中
		}
	}
	String(const String& s)//拷贝构造
		:_pStr(s._pStr)
	{
		++(*(int*)(_pStr-4));//向前偏移4个字节将计数加1
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			if(--(*(int*)(_pStr - 4)) == 0)//向前偏移4个字节判断计数是否为0，是0则释放
			{
				delete (_pStr-4);
				_pStr = NULL;
			}
		}
	}
	String& operator=(const String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)
		{
			if(--(*(int*)(_pStr - 4)) == 0)//释放旧空间
			{
				delete (_pStr-4);
				_pStr = NULL;
			}
		    _pStr = s._pStr;//指向新空间
			++(*(int*)(_pStr - 4));//计数加1
		}
		return *this;
	}
	char& operator[](size_t index)//下标访问操作符重载
	{
		assert(index>=0 && index<strlen(_pStr));
		if(*((int*)(_pStr-4)) > 1)//说明有多个对象指向同一块空间
		{
			char* temp = new char[strlen(_pStr) + 4 + 1];//新开辟一块空间
			temp += 4;//先将开辟的空间向后偏移4个字节
			strcpy(temp,_pStr);//将_pStr的内容拷贝到temp中
			--(*(int*)(_pStr-4));//将原来空间的计数器减1

			_pStr = temp;//将当前对象指向临时空间
			*((int*)(_pStr-4)) = 1;//将新空间的计数器变为1
		}
		return _pStr[index];
	}
private:
	char* _pStr;
};

void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	s3[2] = 'g';
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}

int main()
{
	Funtest();
	system("pause");
	return 0;
}

运行过程：

创建好s1，s2，s3后：



改变s3的内容：



s3的值被改变后：



对s4进行赋值后：



如果还不理解，请看下图：



三，深拷贝

        所谓深拷贝，就是为新对象开辟一块新的空间，并将原对象的内容拷贝给新开的空间，释放时就不会牵扯到多次析构的问题。


//深拷贝(普通版)
class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)
		{
			*_pStr = '\0';
		}
		else
		{
			strcpy(_pStr,pStr);
		}
	}
	String(const String& s)//拷贝构造
		:_pStr(new char[strlen(s._pStr)+1])
	{
		strcpy(_pStr,s._pStr);
	}
	String& operator=(const String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)//判断是否自己给自己赋值
		{
			char* temp  = new char[strlen(s._pStr)+1];//先开辟一段新空间
			strcpy(temp,s._pStr);//将原对象的值赋给新空间
			delete []_pStr;//释放当前对象
			_pStr = temp;//将当前对象指向新开辟的空间
		}
		return *this;
	}
		~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			delete[]_pStr;
			_pStr = NULL;
		}
	}
private:
	char* _pStr;
};

void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
	Funtest();
	system("pause");
	return 0;
}

运行过程：



仔细观看上图，你会发现虽然4个对象指向的内容一样，不过地址却均不相同，说明它们各自占各自的空间，出来值相同外，没什么联系，析构起来当然也不会有问题了。


下面看下简洁版的深拷贝：

//深拷贝(简化版1)
class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)
		{
			*_pStr = '\0';
		}
		else
		{
			strcpy(_pStr,pStr);
		}
	}
	String(const String& s)//拷贝构造
		:_pStr(new char[strlen(s._pStr)+1])
	{
		strcpy(_pStr,s._pStr);
	}
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			delete[]_pStr;
			_pStr = NULL;
		}
	}
	String& operator=(const String& s)//赋值运算符重载
	{
		if(_pStr != s._pStr)
		{
           delete[]_pStr;
           _pStr = new char[strlen(s._pStr)+1];
			strcpy(_pStr,s._pStr);
		}
		return *this;
	}
private:
	char* _pStr;
};

void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
    Funtest();
	system("pause");
	return 0;
}


//深拷贝（简洁版2）
class String
{
public:
	String(const char* pStr = "")//构造函数
		:_pStr(new char[strlen(pStr)+1])
	{
		if(0 == *pStr)
		{
			*_pStr = '\0';
		}
		else
		{
			strcpy(_pStr,pStr);
		}
	}
	String(String& s)//拷贝构造
		:_pStr(NULL)//防止交换后temp指向随机空间，本函数调用结束导致内存泄漏以致崩溃
	{
	    String temp(s._pStr);//如果不给出临时变量，交换后s的值将为NULL
		std::swap(_pStr,temp._pStr);
	}
//1
	String& operator=(const String &s)//赋值运算符重载
	{
		if(_pStr != s._pStr)
		{
			String temp(s._pStr);//如果不给出临时变量，交换后s的值将为NULL
		    std::swap(_pStr,temp._pStr);
		}
		return *this;
	}
	/* 2
	String& operator=(const String& s)
	{
	if (this != &s)
	{
	String temp(s);
	std::swap(_pStr, temp._pStr);
	}
	return *this;
	}*/

	/* 3
	String& operator=(String temp)
	{
		std::swap(_pStr, temp._pStr);
		return *this;
	}*/
	~String()//析构函数
	{
		if(NULL == _pStr)
		{
			return;
		}
		else
		{
			delete[]_pStr;
			_pStr = NULL;
		}
	}
private:
	char* _pStr;
};

void Funtest()
{
	String s1("abcd");
	String s2(s1);
	String s3 = s2;//调用拷贝构造函数(编译器会s2直接初始化s3)
	String s4;//s4对象已经存在了
	s4 = s3;//编译器会调用赋值运算符重载将s3的值赋给s4
}
int main()
{
	Funtest();
	system("pause");
	return 0;
}


Fighting!!!


snow_5288
关注
专栏目录
解决String深浅拷贝
weixin_53946312的博客
08-05 356
解决String深浅拷贝浅拷贝和深拷贝深拷贝实现写时拷贝String三级目录 浅拷贝和深拷贝 浅拷贝： 浅拷贝也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就导致多个对象共同享用同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进行操作时，就会发生访问违规 深拷贝： 给每个对象独立分配资源，保证多个对象之间不会因为共享资源而造成多次释放造成程序崩溃问题 关于深浅拷贝解决方案有两种 1、深拷贝 2、引用计数拷贝+写时拷
【C语言】String类的写时拷贝
weixin_33904756的博客
02-28 73
有了引用计数器以后为什么还有写时拷贝呢？因为当我有两个String类s1,s2都是指向同一块空间“helle”,当我想将s1修改成“hello”时，我只想将s1指向的空间修改，而不想将s2修改，显然引用计数器不能解决这个问题，所以就有了更完善的写法--写时拷贝。写时拷贝classString { public: String(char*str="") ...
【爱上C++】详解string类2:模拟实现、深浅拷贝
最新发布
2301_76677973的博客
07-01 2001
在上一篇文章中我们介绍了string类的基本使用，本篇文章我们将讲解string类一些常用的模拟实现，其中有很多细小的知识点值得我们深入学习。Let’s go！
C++的std::string的“读时也拷贝”技术！
陈皓专栏　【空谷幽兰，心如皓月】
10-13 6336
C++的std::string的“读时也拷贝”技术！赵锟原文：http://coolshell.cn/?p=1443 C++的std::string的读时也拷贝技术！嘿嘿，你没有看错，我也没有写错，是读时也拷贝技术。什么?我的错，你之前听说写过时才拷贝，嗯，不错的确有这门技术，英文是Copy On Write，简写就是COW,非常’牛’！那么我们就来看看这个’牛’技术的效果吧。
string类的写时拷贝与引用计数
Ego_Bai的博客
10-17 466
由于浅拷贝使多个对象共用一块内存地址，调用析构函数时导致一块内存被多次释放，导致程序奔溃。实现string类的时候通常显示的定义拷贝构造函数和运算符重载函数。由于释放内存空间，开辟内存空间时花费时间，因此，在我们不需要写，只是读的时候就可以不用新开辟内存空间，就用浅拷贝的方式创建对象，当我们需要写的时候才去新开辟内存空间。这种方法就是写时拷贝。在构造函数中开辟新的空间时多开辟4个字节的空间，用来存放
string类的写时拷贝
Mylily_123的博客
03-17 376
如图所示，str1和str2指向的内存中内容是一样的，如果系统浅拷贝的话，一个释放后，另一个释放时找不到要是放的内存；如果自己实现深拷贝，会出现内存浪费。所以实现string类的写时拷贝。 引用计数放在什么地方合适呢？ 1、放在类中 作为普通成员变量，那么每个对象中都有一个count，不能实现共用； 作为静态成员变量，定义str1和str2后，count...
详解C++中String类模拟实现以及深拷贝浅拷贝
08-28
为了解决深拷贝中的资源管理问题，又提供了带有引用计数的String类实现。引用计数记录了有多少个对象共享同一资源，当对象被销毁时，先减少引用计数，如果引用计数降至0，则释放该资源。在拷贝构造函数中，引用计数...
C++ string类的隐式共享写时拷贝的实现及设计要点
ljianhui的专栏
04-04 8039
字符串一种在程序中经常要使用到的数据结构，然而在C中却没有字符串这种类型。在C++中，为了方便字符串的使用，在STL中提供了一个string类。该类维护一个char指针，并封装和提供各种的字符串操作。 一、为什么要实现隐式公享写时拷贝 试想一下，如果我们要自己实现一个string类，最简单的方式是什么？就是让每一个string类的实例维护一个在内存中独立的字符数组，每个string对象
深拷贝(mutableCopy)与浅拷贝(Copy)详解
jeikerxiao
04-15 826
简单的来说就是，在有指针的情况下， 浅拷贝只是增加了一个指针指向已经存在的内存; 深拷贝就是增加一个指针并且申请一个新的内存，使这个增加的指针指向这个新的内存。 采用深拷贝的情况下，释放内存的时候就不会出现在浅拷贝时重复释放同一内存的错误。 阅读本文之前首先了解copy与retain的区别 copy与retain的区别：copy是创建一个新对象，retain是创建一个指针
详解javascript常用工具类的封装
11-26
长度与计数len (o) { //获取字符串或数组长度if (this.isString(o)) {return o.length;} else if (this.isArray(o)) {return o.length;} else if (this.isObj(o)) {return Object.keys(o).length;} else {return 0;...
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
热门推荐
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
String 深拷贝
青云衣兮白霓裳
10-22 330
class String { private: char* _str; }; 1.传统写法完成String深拷贝。 2.现代写法完成String深拷贝。
String的深拷贝
Qiana_wq的博客
07-23 1273
String的深拷贝是一种拷空间拷数据的方法。String的浅拷贝是一种拷数据的方法，只是将指针指向同一块空间，在析构的时候会出错，同一个空间释放多次。深拷贝就是解决浅拷贝的析构问题，但深拷贝会有开辟空间的开销。对此，提出引用计数的浅拷贝，也就是写时拷贝。写时拷贝在下一篇博客中写。 #include<iostream> using namespace std; //传统写法：开空间，拷数据 cla
String类之 深拷贝
qq_39412582的博客
08-14 624
上篇博客我们说浅拷贝存在同一块资源被多次释放的问题，那么这篇博客就是给浅拷贝擦屁股，解决它遗留下来的问题。 解决这个问题，我们可以考虑单独给 s2 开辟一块空间，只将 s1 里的内容拷贝到 s2。 看一看我们代码是怎么实现的吧： class String { public: String(const char* pStr = &quot;&quot;) { if (NULL ==...
string的写时拷贝
yangrujing的专栏
08-28 669
#include<iostream> #pragma warning(disable:4996) using namespace std;//class String //{ //public: // String(char* str = " ") // :_str(new char[strlen(str) + 1]) //多一个字节存‘\0’ // , _pRefcount
标准C＋＋类std::string的内存共享和Copy-On-Write（写时拷贝）
weixin_30725467的博客
05-09 359
标准C＋＋类std::string的内存共享，值得体会： 详见大牛：https://www.douban.com/group/topic/19621165/ 顾名思义，内存共享，就是两个乃至更多的对象，共同使用一块内存； 1.关于string的内存共享问题： 通常，string类中必有一个私有成员，其是一个char*，用户记录从堆上分配内存的地址，其在构造时分配内存，在析构时释...
String类引用计数的写时拷贝
AlwenZwei的博客
07-13 500
写时拷贝： 当一个对象被拷贝构造多次，在不改变内容的情况下，多个对象共用同一个空间。 如果某个对象要改变内容，就要另外开辟一块相同的空间，然后改变这个对象的_str指针，再进行写操作 #include #include using namespace std; //String类的浅拷贝增删查改（引用计数的写时拷贝） class String { public: String(c
string类的引用计数的写时拷贝分析
WX Never Give Up！
09-13 261
写时拷贝（copy-on-write） 使用了引用计数的复制方法，在复制的时候会有一个变量来保存引用的次数，类似于： 假设A要管理S1这块空间，然后B也想要管理使用S1，写时拷贝不需要把S1复制一份再让B去管理修改，而是将B的指针指向S1这块空间，则S1就被A和B同时管理使用，减少了系统开支，提升了系统性能。 但是在程序结束调用析构函数进行释放空间的时候
c++string的深拷贝
zhang1308299607的博客
07-10 1万+
在c++中当我们想要去拷贝一个字符串的时候就会存在两种方式： 1 浅拷贝方式                   2深拷贝方式 浅拷贝： 所谓的浅拷贝就是让当前的指针指向一块已存在的区域，和其他指针共享同一块地址空间 浅拷贝所带来的问题是当程序结束的时候，对象d1和d2都会去调用析构函数清零这个快空间，而一块空间析构两次可能就会导致程序崩溃。（这里暂不考虑写时拷贝） 深拷
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值