C C++最新C++之string的底层简单实现！（七千字长文详解）_c(2)，2024年教你增加拿到BAT等大厂offer几率

最新推荐文章于 2024-07-26 11:04:03 发布
最新推荐文章于 2024-07-26 11:04:03 发布
阅读量886 收藏 9
点赞数 29
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84975342/article/details/138881251
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

+=重载
string& operator+=(char c)
{
	Push\_Back(c);
	return \*this;
}
string& operator+=(const char\* str)
{
	append(str);
	return \*this;
}
insert
插入一个字符

insert是一个坑很多的接口接下来先给读者看一个错误的写法！

string& insert(size_t pos, char c)
{
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity \* 2;
		reserve(newcapacity);
		_capacity = newcapacity;
	}
	size_t end = _size;
	while (end >= pos)
	{
		_str[end + 1] = _str[end];
		end--;
	}
	_str[pos] = c;
	_size++;
	return \*this;
}

这个写法看上去是没有什么问题的！但是其实，在第0位插入的时候会陷入死循环！

为什么？因为size_t是一个无符号位！

一旦小于 0 就会变成一个极大的值！也就是说 永远无法小于 pos！

image-20221108221438334.png

那如果我们把end的类型换做int这个有符号位是否能解决这个问题呢？

答案是不行！因为发生了整形提升！当左右运算符左右的两个类型相似的时候！为了确保精度！编译器会自动的将低精度的类型提升为高精度的类型！

image-20221108223247908.png

所以其实实际上这个表面上是int类型的end变量，实际上是size_t类型的！

就看到end好像就是不断的减下去不停止！

如果要使用int类型的end变量来解决这个问题！还必须将pos强转为int类型防止发生整形提升！

string& insert(size_t pos, char c)
{
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity \* 2;
		reserve(newcapacity);
		_capacity = newcapacity;
	}
	int end = _size;
	while (end >= (int)pos)
	{
		_str[end + 1] = _str[end];
		end--;
	}
	_str[pos] = c;
	_size++;
	return \*this;
}

image-20221108223133913.png

结果成功的插入了！

还有一种解决方法就是不让end 小于 0

就是让end的开始位置从 '\0’的下一位开始！

string& insert(size_t pos, char c)
{
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity \* 2;
		reserve(newcapacity);
		_capacity = newcapacity;
	}
	size_t end = _size + 1;
	while (end > pos)//不可以 >= 因为一旦 == 就会导致 end == 0 随后end-- 变成-1 其实是一个极大的值！
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = c;
	_size++;
	return \*this;
}

image-20221108224020969.png

插入一个字符串

用insert插入一个字符串的难点在于循环的范围！

下面就是一个经典的错误案例

string& insert(size_t pos, const char\* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	size_t end = _size;

	/\*while (end > pos)
 {
 \_str[end] = \_str[end - len];
 end--;
 }\*///循环1
 /\*while (end >= pos)
 {
 \_str[end+len] = \_str[end];
 end--;
 }\*///循环2

 while (end > pos)
	{
		_str[end] = _str[end - len];
		end--;
	}//循环3
	strcpy(_str + pos, str);
	return \*this;
}
int main()
{
	MySTL::string s1 = "hello";
	s1.insert(0, "hhh");
	cout << s1.c\_str() << endl;
	return 0;
}
  1. 首先是循环范围这个循环其实其实已经发生了越界访问！

当end < len的时候 就会出现一个极大值！此时已经出现了越界的访问！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VtyL3eRM-1668311036147)(https://s2.51cto.com/images/202211/89142d780c3b6eb765c052871abc7a40b89a22.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)]

2 . 第二种循环的问题就是和上面的一样一旦遇到pos = 0 的位置的时候就会进入死循环！解决的方法也是一样的！就是将end类型换成int 将pos强转为int

int end = _size;
while (end > (int)pos)
{
	_str[end] = _str[end - len];
	end--;
}

3.第三种循环会出现！会出现越界访问！当end < len的时候！end -len就会变成一个极大的值！

4 . 然后是strcpy，因为拷贝的过程中将\0也一起拷贝进去了，所以一旦打印出结果就只有插入的值，而插入后面的值都无法显示！

image-20221108230044881.png

insert的正确写法

string& insert(size_t pos, const char\* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	size_t end = _size + len
        ;//从最后的\0的位置开始！
	while (end > pos + len - 1)
        //如果不pos +len-1 会导致少移动一个字符！
	{
		_str[end] = _str[end - len];
		end--;
	}
	strncpy(_str + pos, str, len);//不可以把str的\0也拷贝进去！
	_size += len;
	return \*this;
}


while (end > pos + len - 1);
//如果改成
while (end >= pos + len);
//当pos == 0 ，len == 0 ，end == 0的时候！就会进入死循环！
//因为end-- 变成一个极大的值！一直死循环！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4bWqpyw2-1668311036148)(https://s2.51cto.com/images/202211/c399897028905a59197927d2b454ed71afc128.png?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)]

while (end > pos + len - 1);
//这个条件循环在end == 0 ，pos == 0，len == 0 的条件下！
//因为 pos + len — 1 也是被整形提升了！所以结果是一个无符号数！导致了小于 0 之后变成了一个极大值！这个情况下无法进入循环刚刚好避免了上面的问题！

返回值一定要是string& 而不是 string！这样可以防止没有写拷贝构造的时候发生调用了两次析构用来释放同一块空间！

默认拷贝构造是浅拷贝！使用string作为返回值就会让临时产生变量中的_str指向同一块的空间！

image-20221109215325168.png

一旦空间被释放，我们插入的值和原先的值都会清空！

image-20221110095446705.png

不仅打印错误还出现了崩溃！

erase

string& erase(size_t pos, size_t len = npos)
{
	size_t end = _size;
	if (len == npos || len >= _size - pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}//当len不传值的时候，和len大于剩下空间的时候！
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
	return \*this;
}

返回值一定要是string& 而不是 string！理由和上面一样都是为了防止二次释放！

find

size_t find(char ch, size_t pos = 0)const
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
	return npos;
}
size_t find(const char\* str, size_t pos = 0)const
{
	const char\* ptr = strstr(_str + pos, str);//要加pos是因为从pos的位置开始找的！
	if (ptr == nullptr)
	{
		return npos;
	}
	else
	{
		return ptr - _str;
	}

}

clear

void clear()
{
	_str[0] - '\0';
	_size = 0;
}

>>的重载！

ostream& operator<< (ostream& out, const string& str)
{
	for (size_t i = 0; i < str.size(); i++)
	{
		out << str[i];
	}
	return out;
}

流插入的重载相比以前的对于c的字符串的打印有个特点就是不以\0作为结尾！

image-20221110110958246.png

<< 重载！

istream& operator >>(istream& in, string& str)
{
    str.clear();
	char ch;
	in >> ch;
	while (ch != '\n' && ch != ' ')
	{
		in >> ch;
		str += ch;
	}
	str += '\0';
	return in;
}

这样写看上去没有问题！但是其实这样写会进入死循环！

这是因为cin将空格和换行当做是多个字符串之间的间隔！所以cin 是拿不到 空格和 \0

所这样写是错误的！

正确写法！

istream& operator >>(istream& in, string& str)
{
    str.clear();
	char ch;
	ch = in.get();
	while (ch != '\n' && ch != ' ')
	{
		str += ch;
		ch = in.get();
	}
	return in;
}

in.get(),就相当于c语言中的getchar！可以提取空格和换行！

但是这个代码有一个不好的一点！

一旦我们输入一串及其长的字符！那么就会频繁扩容！这样会导致不必要的性能损失！

所以我们可以继续改进一些！

最终优化版！

istream& operator >>(istream& in, string& str)
{
    str.clear();//用来清空str保留的数据！
	char buff[128] = { '\0' };
	char ch;
	ch = in.get();
	int i = 0;
	while (ch != '\n' && ch != ' ')
	{
        if (i == 127)//留一个用来存放\0 如果i == 128的话！会导致乱码！因为+=的底层是append，append是调用strcpy来实现的！strcpy是以\0作为结尾的！
		{
			i = 0;
			str += buff;
		}
		buff[i++] = ch;
		ch = in.get();
	}
	if (i > 0)
	{
		buff[i] = '\0';//如果不加上这个的话会把后面原本的值都拷进去！
		str += buff;
	}
	return in;
}
	//getline的实现原理就是把条件换成while (ch != '\n')

将要输入的长字符串分割成一个个小段！减少扩容的次数！

最终代码

namespace MySTL
{
	class string
	{
	public:
		typedef char\* iterator;
		typedef const char\* const_iterator;
		iterator begin()
		{
			return _str;
		}
		const_iterator begin()const
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator end()const
		{
			return _str + _size;
		}

		string(const char\* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		~string()
		{
			_size = _capacity = 0;
			delete[] _str;
			_str = nullptr;
		}
		string(const string& str)
		{
			_str = new char[str._capacity + 1];
			strcpy(_str, str._str);
			_capacity = str._capacity;
			_size = str._size;
		}
		string& operator=(const string& str)
		{
			if (this == &str)
			{
				char\* temp = new char[str._capacity + 1];
				strcpy(temp, str._str);
				delete[] _str;
				_str = temp;
				_capacity = str._capacity;
				_size = str._size;
			}
			return \*this;
		}
		const char\* c\_str()const
		{
			return _str;
		}

		size_t size()const
		{
			return _size;
		}

		size_t capacity()const
		{
			return _capacity;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			char\* temp = new char[n + 1];
			strcpy(temp, _str);
			delete[] _str;
			_str = temp;
			_capacity = n;
		}
		void resize(size_t n ,char ch = '\0')
		{
			assert(n >= 0);
			if (n <= _size)
			{
				_str[n] = '\0';
				_size = n;
			}
			else if (n > _size && n <= _capacity)
			{
				while (_size < n)
				{
					_str[_size] = ch;
					_size++;
				}
				_str[_size] = '\0';
			}
			else
			{
			
				reserve(n);
				while (_size < n)
				{
					_str[_size] = ch;
					_size++;
				}
				_str[_size] = '\0';
				_capacity = n;
			}
		}



		void Push\_Back(char c)
		{
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity \* 2;
				reserve(newcapacity);
				_capacity = newcapacity;
			}
			_str[_size] = c;
			_size++;
			_str[_size] = '\0';
		}

		void append(char c)
		{
			Push\_Back(c);
		}


		void append(const char\* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			//strcat(\_str, str);
			strcpy(_str + _size, str);
			_size += len;
		}
		string& operator+=(char c)
		{
			Push\_Back(c);
			return \*this;
		}
		string& operator+=(const char\* str)
		{
			append(str);
			return \*this;
		}
		const char& operator[](size_t pos)const
		{
			assert(pos < _size);
			return _str[pos];
		}

		string& insert(size_t pos, char c)
		{
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity \* 2;
				reserve(newcapacity);
				_capacity = newcapacity;
			}

			size_t end = _size + 1;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[pos] = c;
			_size++;
			return \*this;
		}

		string& insert(size_t pos, const char\* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			size_t end = _size + len;
			while (end >= pos + len)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
			return \*this;
		}
		string& erase(size_t pos, size_t len = npos)
		{
			size_t end = _size;
			if (len == npos || len >= _size - pos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return \*this;
		}
		size_t find(char ch, size_t pos = 0)const
		{
			assert(pos < _size);
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}
			return npos;
		}
		size_t find(const char\* str, size_t pos = 0)const
		{
			const char\* ptr = strstr(_str + pos, str);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}

		}
		void clear()
		{
			_str[0] - '\0';
			_size = 0;
		}
	private:
		char\* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos = -1;
	
	};
	ostream& operator<< (ostream& out, const string& str)
	{
		for (size_t i = 0; i < str.size(); i++)
		{
			out << str[i];
 }
 return out;
 }

 istream& operator >>(istream& in, string& str)
	{

		str.clear();
		char buff[128] = { '\0' };
		char ch;


![img](https://i-blog.csdnimg.cn/blog_migrate/dfca8150cf262b6c474cdcddf31fbe1f.png)
![img](https://img-blog.csdnimg.cn/img_convert/11a91661c5a61f60ff5cd1ef30529692.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

			}
			else
			{
				return ptr - _str;
			}

		}
		void clear()
		{
			_str[0] - '\0';
			_size = 0;
		}
	private:
		char\* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos = -1;
	
	};
	ostream& operator<< (ostream& out, const string& str)
	{
		for (size_t i = 0; i < str.size(); i++)
		{
			out << str[i];
 }
 return out;
 }

 istream& operator >>(istream& in, string& str)
	{

		str.clear();
		char buff[128] = { '\0' };
		char ch;


[外链图片转存中...(img-p1WhZKSR-1715713484483)]
[外链图片转存中...(img-AycTCJSw-1715713484484)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84975342
关注
专栏目录
JAVA新版本特性(10万字长文详解)完全指导手册
hao_kkkkk的专栏
04-01 787
这里帮你梳理为何JDK 17将会是一个极为重要的版本以及如何去理解它Java 9 正式发布于 2017 年 9 月 21 日。作为 Java8 之后 3 年半才发布的新版本，Java 9 带来了很多重大的变化。其中最重要的改动是 Java 平台模块系统的引入。除此之外，还有一些新的特性。本文对 Java9 中包含的新特性做了概括性的介绍，可以帮助你快速了解 Java 9作为当今使用最广泛的编程语言之一的 Java 在 2018 年 3 月 21 日发布了第十个大版本。
string的底层实现(带注释)
a1912157861的博客
08-09 1675
string底层实现关于string的默认构造函数关于string 的运算符重载函数string的增删改查操作 关于string的默认构造函数 首先定义一个域，在域中创建一个名为string的类，此类中所需的私有成员变量具体为: 此中，_str表示的是字符串的首地址指针，_size表示的是当前字符串中存储了字符的长度，_capacity表示的是当前字符串的最大存储容量，npos此处是string中定义的静态常量。 一.带缺省参数的构造函数 此处如果不传参str就只为当前对象开个空间，并将对象置为空，如果
C++之string的底层简单实现！（七千字长文详解）
m0_74376760的博客
11-13 1182
string底层实现详解！
C++的string底层剖析
weixin_44164489的博客
09-16 2612
本文部分内容转自此博客。 目录Eager Copy 深拷贝COW(Copy-On-Write) 写时复制SSO（Short String Optimization）短字符串优化最佳策略线程安全性COW 写时复制的代码实现内存增长策略总结 我们都知道， std::string的一些基本功能和用法，但它底层到底是如何实现的呢? 其实在std::string的历史中，出现过几种不同的方式。 可以从一个简单的问题来探索，一个std::string对象占据的内存空间有多大，即 sizeof(std::string)的
【c++】string的底层实现
m0_72964546的博客
09-23 825
交换函数就近原则，会先找局部的，所以使用类作用域操作符（::）； 为什么要把_str定义为nullptr，如果不定义那么_str内是随机值，和tmp交换后，出函数tmp生命周期结束，调析构函数清理一块没有权限的空间，不可以；
C++ string底层原理
qq_50408340的博客
11-18 6278
一、深浅拷贝 浅拷贝： 在实现string时要是不实先string拷贝构造，会自动生成一个拷贝构造函数，但是他只是一个浅拷贝。两个string对象指向同一个地址，在两个对象调用析构函数是，前一个对象调用的析构函数已经释放了这个地址的内从，而后一个会重复释放该块空间，导致出错。 会触发断点，然后报错. class string { public: /*string() :_str(new char[1]) {*_str = '\0';} */ //string(const char* str = "\0"
详解C++ sizeof（上）
08-18
C++语言中的sizeof是一个操作符，用于返回对象或类型所占内存的字节数。这个操作符在编程中使用得非常频繁，因此对其有一个全面的了解对于学习C++是非常重要的。 sizeof的操作符有三种语法形式： 1. sizeof(object)...
C++编程基础：数据类型详解
C++还提供了字符串的表示，通常是通过字符数组实现，但在标准库中，也有如std::string这样的类抽象，提供更高级别的操作。 C++的数据类型系统不仅限于基本类型，还包括类抽象，如标准库中的std::string和容器类，...
C++之类和对象
m0_62633482的博客
03-05 630
C++类和对象（2w字详解）
【C++】string 的底层实现
m0_64645696的博客
03-03 1671
首先string的内置成员有： char* _str; size_t _size; size_t _capacity; static const size_t npos; 实现的原理有： 构造函数： string(const char* str = "") { _size = strlen(str); _capacity = _size; _str = new char[_capacity + 1]; strcpy(_str, str); }
c++(string)
最新发布
2301_79941274的博客
07-26 435
解决方案：a.内联(inline)/静态(static)只在当前文件呈现。查找在str1中的str2，找到则返回str2在str1中的指针。
C++ string的简易底层实现
Currybeefer的博客
11-29 471
string底层实现，参考了网上的一些代码，注释都写在代码里了，比较清楚。
C++ string类底层模拟实现
m0_49337160的博客
03-30 826
目录 一、string介绍 二、string类底层模拟实现 1，默认成员函数的实现 a，构造函数 b，析构函数 c，拷贝构造函数 d，赋值运算符重载 2，常用接口实现 a，Iterator b，Capacity c，Element access d，Modifiers e，String operations f，Non-member function overloads 总代码： 一、string介绍 C语言中，字符串是以 ‘\0’ 结尾的一些字符的集合，...
C++实现string类
琅嬛福地
04-13 685
C++写一个string类，其实更多的是对C++内存分配，运算符重载的功能的运用。 MyString.h #pragma once #include <iostream> using namespace std; class MyString { public: MyString(); //默认构造函数 MyString(int n, char c); //普通构造函数 ...
C++中string类的用法介绍及底层实现
qq_54866651的博客
05-14 685
string是C++标准库的一个重要组成部分，主要用于字符串处理，可以使用输入输出流的方式直接进行string操作，也可以通过文件等手段进行string操作，同时，C++的算法库堆string类也有着很好的支持，并且string类还和C语言的字符串之间有着良好的接口。的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP。C++标准库string类中一些常见接口。结尾的一些字符的集合，为了操作方便，2.1string类构造函数。
C++入门篇之string类的底层原理和模拟实现
满天的博客
08-30 1226
string类的模拟实现和string的底层原理
C++标准库中string的三种底层实现方式
yolan2626的博客
08-31 3386
引言 我们都知道， std::string的一些基本功能和用法，但它底层到底是如何实现的呢? 其实在std::string的历史中，出现过几种不同的方式。 可以从一个简单的问题来探索，一个std::string对象占据的内存空间有多大，即 sizeof(std::string)的值为多大？如果我们在不同的编译器（VC++, GNU, Clang++）上去测试，可能会发现其值并不相同；即使是GNU...
C++ 实现string
LIJIWEI0611的博客
11-14 889
C++ stl string的功能 #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string> using namespace std; int main() { //默认构造函数 string str1; string str2 = "aaa"; string str3 = "bbb"; //+ 运算符重载 string str4 = str2 + str3; st
利用c++实现string
qq_68884672的博客
08-20 394
简单实现my_string的示例；提示：以下是本篇文章正文内容，下面案例可供参考C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛；C++支持多种编程范式面向对象编程、泛型编程和过程化编程。最新正式标准C++于2014年8月18日公布。其编程领域众广，常用于系统开发，引擎开发等应用领域，是至今为止最受广大程序员受用的最强大编程语言之一,支持类：类、封装、重载等特性。版权声明：本文为CSDN博主「がC.」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
C语言教程：理解位字长与常量表示
"C语言教程，讲解了C语言的基本数据类型、流程控制、模块化程序设计等内容，涉及常量、字符类型、数组、指针、用户定制数据类型、文件以及面向对象的程序设计简介。教程指出程序是按照一定顺序安排的工作步骤，提到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值