C++ string类和常用接口的实现

朱雀 2024-04-19 10:17 71阅读 0赞

**目录**

C++ string类

string类的常用接口说明

string类(实现常用接口)

--------------------

# C++ string类 #

> 值得注意的是 , string不是STL的容器，string是basic\_string类模板的一个实例,string是一个模板类, 它使用char来实例basic\_string， string集成的操作函数与STL中容器中的操作函数大部分很相似, 因为sting本身也是用顺序表来实现的(与vector容器类似)
> 
> C++之所以用C++标准程序库中的string来代替C中的char\*(C++中还是可以用char\*, 这是为了与C保持兼容)，是因为它和C中的char\*比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下的需要。我们也可以把string看成是C++的基本数据类型。 
> string定义在标准命名空间std中, 所以要么在用之前加using namespace std; 使string对外可见, 要么不嫌麻烦 std::string 
> 使用string这个模板类要加头文件<string>
> 
> 注意:
> 
> 1. string是表示字符串的字符串类 
> 2.string的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 
> 3. string在底层实际是：basic\_string模板类的别名，typedef basic\_string<char, char\_traits, allocator>string; 
> 4. 不能操作多字节或者变长字符的序列(举个例子, string s = "你好"; 当你pop\_back()时, 并不是删除字符 "好", 而是只删除char类型的的长度也就是1字节, 而汉字在常见编码方式下都比1字节长)

### string类的常用接口说明 ###

> string其中大部分接口与矢量容器vector接口保持一致, 功能用法也一样, 这些与vector保持一致接口用起来就与vector<char> 一样, 这里对这些保持一致的接口并不做过多的说明   , string可以看做在vector<char>的基础上多了一些处理字符串的接口函数                 [链接 :vector接口说明][vector]

**1. string类对象的常见构造**

<table> 
 <thead> 
 <tr> 
 <th style="text-align:center;width:345px;">函数名称</th> 
 <th style="text-align:center;width:432px;">函数功能</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <th style="text-align:center;width:345px;">string ()</th> 
 <td style="width:432px;"> 构造一个空的字符串 </td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string (const char* c_s)</th> 
 <td style="width:432px;">用一个char*类型的字符串c_s来构造一个string类型的的字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string(const char* c_s, size_t n)</th> 
 <td style="width:432px;">截取c_s中前n个字符,&nbsp; 来构造字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string (const char* c_s, size_t pos, size_t npos)</th> 
 <td style="width:432px;">截取c_s中从下标为pos的字符到下标为npos的字符, 来构造字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string (const string&amp; s)</th> 
 <td style="width:432px;">拷贝构造函数, 构造一个与s一模一样的字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string (const string&amp; s, size_t pos)</th> 
 <td style="width:432px;">截取s中从下标为pos的字符开始往后的所有有效字符, 来构造字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string (const string&amp; s, size_t pos, size_t npos)</th> 
 <td style="width:432px;">截取s中从下标为pos的字符到下标为npos的字符, 来构造字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">string (size_t n, char c)</th> 
 <td style="width:432px;">构造一个有n个字符c的字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;"> template &lt;class InputIterator&gt; &nbsp; &nbsp; string (InputIterator begin, InputIterator end) </th> 
 <td style="width:432px;">以区间[begin, end)&nbsp; (不包含end)内的字符作为字符串s的初值, 这里的begin和end是迭代器&nbsp;</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:345px;">~string()</th> 
 <td style="width:432px;">析构</td> 
 </tr> 
 </tbody> 
</table>

来看具体应用 :

//头文件

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

void test() {
 	//string的构造函数
 	string s;//string()
 	string s1("abcdef");//string(const char* s)
 	string s2(4, 'a');	//string(size_t n, char c)
 	string s3(s1);		//string(const string& s)
 	string s4(s1, 3);	//string(const string& s, size_t n)
 	string s5(s1, 1, 5);
 	string s6("abcdefe", 3);
 	string s7("scscssr", 2, 6);
 	cout << typeid(s1.begin()).name() << endl;
 	cout << typeid(*s1.begin()).name() << endl;
 	string::iterator begin = s1.begin();
 	string::iterator end = s1.end();
 	string s8(begin, end);
 	cout << "s: " << endl
 	 << "s1:" << s1 << endl
 		<< "s2:" << s2 << endl
 		<< "s3:" << s3 << endl
 		<< "s4:" << s4 << endl
 		<< "s5:" << s5 << endl
 		<< "s6:" << s6 << endl
 		<< "s7:" << s7 << endl
 		<< "s8:" << s8 << endl;
 	for (int i = 0; begin + i < end; ++i) {
 		cout << *(begin + i);
 	}
 	cout << endl;
 	cout << endl;
 	system("pause");
 	system("cls");
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70][]

> 值得注意的是最后一个函数 string (string::iterator begin, string::iterator end), 其中两个参数都是迭代器, 迭代器是一个变量, 迭代器可以指向string中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和[指针][Link 1]类似。可以看到string中的迭代器变量解引用之后是char类型, 本质上迭代器就是char\*类型 .

**2. string类对象的容量操作**

<table> 
 <thead> 
 <tr> 
 <th style="text-align:center;width:286px;">函数名称</th> 
 <th style="text-align:center;width:454px;">函数功能</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <th style="text-align:center;width:286px;">size_t size() const</th> 
 <td style="text-align:left;width:454px;">返回字符串有效字符长度</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">size_t length() const</th> 
 <td style="width:454px;">返回字符串有效字符长度</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">size_t capacity ( ) const</th> 
 <td style="width:454px;">返回空间总大小</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">bool empty ( ) const</th> 
 <td style="width:454px;">检测字符串是否为空串，是返回true，否则返回false</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">void clear()</th> 
 <td style="width:454px;">清空有效字符(将字符串变成空串)</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">void resize ( size_t n, char c = 0 )</th> 
 <td style="width:454px;">将有效字符的个数(size)改成n个，多出的空间用字符c填充(注意, 字符个数只会增加, 如传入比有效长度小的值则不作操作)</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">void resize ( size_t&nbsp; n )</th> 
 <td style="width:454px;">将有效字符的个数(size)改成n个，多出的空间用字符'\0'填充(注意, 字符个数只会增加, 如传入比有效长度小的值则不作操作)</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:286px;">void reserve ( size_t n = 0 )</th> 
 <td style="width:454px;">为字符串预留空间(扩容, 改变的是容量(capacity)的大小)(注意, 扩容只会增加, 如传入比原容量小的值则不作操作)</td> 
 </tr> 
 </tbody> 
</table>

> 注意 :
> 
> size函数和length作用是一样的
> 
> resize和reserve都只能向大调整
> 
> resize函数会调用reserve函数

void test1() {
 	string s1("abcdef");//string(const char* s)
 	string s2(4, 'a');	//string(size_t n, char c)
 	string s3(s1);		//string(const string& s)
 	cout << "sting类的容量操作\n";
 	cout << "s1有效长度是:" << s1.size() << endl;
 	//size_t size() const 返回字符串有效字符长度
 	cout << "s1有效长度是:" << s1.length() << endl;
 	//size_t length() const 返回字符串有效字符长度
 	cout << "s2有效长度是:" << s2.size() << endl;
 	cout << "s2有效长度是:" << s2.length() << endl;
 	cout << "s1的容量是:" << s1.capacity() << endl;
 	//size_t capacity() const 返回空间总大小
 	cout << "s2的容量是:" << s2.capacity() << endl;
 	s1.reserve(20);
 	//void reserve(size_t res_arg = 0) 为字符串预留空间
 	cout << "s1有效长度是:" << s1.size() << endl;
 	cout << "s1的容量是:" << s1.capacity() << endl;
 	s2.resize(25);
 	//void resize(size_t n) 将有效字符的个数改成n个，多出的空间用0填充
 	cout << "s2有效长度是:" << s2.size() << endl;
 	cout << "s2的容量是:" << s2.capacity() << endl;
 	s2 += "字符串结束";
 	cout << "s2:" << s2 << endl;
 	s3.resize(20, 'z');
 	//void resize(size_t n, char c) 将有效字符的个数该成n个，多出的空间用字符c填充
 	cout << "s3有效长度是:" << s3.size() << endl;
 	cout << "s3的容量是:" << s3.capacity() << endl;
 	cout << "s3:" << s3 << endl;
 	s1.empty() ? cout << "s1为空\n" : cout << "s1不为空!\n";
 	//bool empty() const 检测字符串释放为空串，是返回true，否则返回false
 	cout << "清空s2\n";
 	s2.clear();
 	s2.empty() ? cout << "s2为空\n" : cout << "s2不为空!\n";
 	system("pause");
 	system("cls");
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1][]

**3.string类对象的访问操作**

<table> 
 <thead> 
 <tr> 
 <th style="text-align:center;width:316px;">函数名称</th> 
 <th style="text-align:center;width:391px;">函数功能</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <th style="text-align:center;width:316px;">char&amp; operator[] ( size_t pos )</th> 
 <td style="width:391px;">返回pos位置的字符，const string类对象调用</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:316px;">const char&amp; operator[] (size_t pos) const</th> 
 <td style="width:391px;">返回pos位置的字符，非const string类对象调用</td> 
 </tr> 
 </tbody> 
</table>

void test2() {
 	//string类对象的访问操作
 	string s1("abcdef");
 	const string s2("xyz");
 	cout << "s1:" << s1 << endl;
 	for (size_t i = 0; i < s1.size(); ++i) {
 		cout << s1[i] << " ";
 		//char& operator[] ( size_t pos ) 返回pos位置的字符，非const string类对象调用
 	}
 	cout << endl;
 	cout << "s2:" << s2 << endl;
 	for (size_t i = 0; i < s2.size(); ++i) {
 		cout << s2[i] << " ";
 		//char& operator[] ( size_t pos ) 返回pos位置的字符，const string类对象调用
 	}
 	cout << endl;
 	system("pause");
 	system("cls");
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2][]

** 4. string类对象的修改操作**

<table> 
 <thead> 
 <tr> 
 <th style="text-align:center;width:217px;">函数名称</th> 
 <th style="text-align:center;width:400px;">重载函数</th> 
 <th style="text-align:center;width:233px;">函数功能</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <th style="text-align:center;width:217px;">void push_back(char c)</th> 
 <th style="text-align:center;width:400px;">/</th> 
 <td style="width:233px;">在字符串后尾插字符c</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:217px;">string&amp; append</th> 
 <th style="text-align:center;width:400px;"> string&amp; append (const string&amp; str);&nbsp; string&amp; append (const string&amp; str, size_t subpos, size_t sublen);&nbsp; &nbsp; string&amp; append (const char* s);&nbsp; &nbsp; string&amp; append (const char* s, size_t n); string&amp; append (size_t n, char c);&nbsp; template &lt;class InputIterator&gt; &nbsp; &nbsp; string&amp; append (InputIterator first, InputIterator last);&nbsp; </th> 
 <td style="width:233px;">在字符串后尾插字符或字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:217px;">string&amp; operator+=</th> 
 <th style="text-align:center;width:400px;"> string&amp; operator+= (const string&amp; str); string&amp; operator+= (const char* s);&nbsp; &nbsp; string&amp; operator+= (char c); </th> 
 <td style="width:233px;"> 在字符串后追加一个字符串s在字符串后追加一个C字符串s 在字符串后追加字符c </td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:217px;">const char* c_str( )const&nbsp;</th> 
 <th style="text-align:center;width:400px;">/</th> 
 <td style="width:233px;">返回C格式字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:217px;">size_t find&nbsp;</th> 
 <th style="text-align:center;width:400px;"> size_t find (const string&amp; str, size_t pos = 0) const;&nbsp; &nbsp; size_t find (const char* s, size_t pos = 0) const;&nbsp; &nbsp; size_t find (const char* s, size_t pos, size_t n) const;&nbsp; &nbsp; size_t find (char c, size_t pos = 0) const; </th> 
 <td style="width:233px;">从字符串pos位置开始往后找字符或字符串，返回其在此字符字符串中的位置</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:217px;">size_t rfind</th> 
 <th style="text-align:center;width:400px;"> size_t rfind (const string&amp; str, size_t pos = npos) const; &nbsp; size_t rfind (const char* s, size_t pos = npos) const; size_t rfind (const char* s, size_t pos, size_t n) const; &nbsp; size_t rfind (char c, size_t pos = npos) const; </th> 
 <td style="width:233px;">从字符串pos位置开始往前找字符或字符串，返回其在此字符串中的位置</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:217px;">string substr(size_t pos = 0, size_t n = npos)const</th> 
 <th style="text-align:center;width:400px;">/</th> 
 <td style="width:233px;">在str中从pos位置开始，往后截取n个字符,然后返回内容是这n个字符的字符串</td> 
 </tr> 
 </tbody> 
</table>

void test3() {
 	string s("abcdef");
 	string s1("higk");
 	string s2("qrst");
 	cout << "s:" << s << endl;
 	s.push_back('g');//void push_back(char c) 在字符串后尾插字符c
 	cout << "s:" << s << endl;
 	s.append(s1);//string& append (const char* s); 在字符串后追加一个字符串
 	s.append("dsscs");
 	s.append(8, 'a');
 	cout << "s:" << s << endl;
 	s += "lmnop";//string& operator+=(const char* s) 在字符串后追加一个字符串
 	cout << "s:" << s << endl;
 	s += s2;//string& operator+=(const string& str)在字符串后追加sting类字符串str
 	cout << "s:" << s << endl;
 	s += 'u';//string& operator+=(char c) 在字符串后追加字符c
 	cout << "s:" << s << endl;
 	s.pop_back();//void pop_back() 删除字符串最后一个字符
 	cout << "s:" << s << endl;
 	const char* c_s = s1.c_str();//const char* c_str( )const 返回C格式字符串
 	cout << "c_s:" << c_s << endl;
 	char c = 'd';
 	size_t pos = 0;
 	size_t n = s.find(c, pos);//pos<s.size();否则会发生访问越界
 	//size_t find (char c, size_t pos =0)const //pos是缺省参数, 不传就是从0开始
 	//从字符串pos位置开始往后找字符c，找到字符返回字符串中的下标,找不到返回-1, 
 //因为返回值是size_t所以是4294967295
 	n != (size_t)-1 ? cout << c << "在字符串s中下标为" << n << "的位置\n" :
 		cout << c << "不在从下标" << pos << "位置开始往后的字符串中\n";
 
 	n = s.find(s1/*缺省参数默认0*/);//pos<s.size();否则会发生访问越界
 	//size_t find (string c, size_t pos =0)const //pos是缺省参数, 不传就是从0开始
 	//从字符串pos位置开始往后找字串c，找到字符串c
 	//返回c在被找字符串中的下标,找不到返回-1, 因为返回值是size_t所以是4294967295
 	n != (size_t)-1 ? cout << s1 << "在字符串s中下标为" << n << "的位置\n" :
 		cout << s1 << "不在从下标" << pos << "位置开始往后的字符串中\n";
 
 	n = s.rfind(c_s, s.size() - 1);//pos<s.size();否则会发生访问越界
 	//size_t find (char* c, size_t pos =0)const //pos是缺省参数, 不传就是从0开始
 	//从字符串pos位置开始往后找字串c，找到字符串c
 	//返回c在被找字符串中的下标,找不到返回-1, 因为返回值是size_t所以是4294967295
 	n != (size_t)-1 ? cout << c_s << "在字符串s中下标为" << n << "的位置\n" :
 		cout << c_s << "不在从下标" << pos << "位置开始往后的字符串s中\n";
 
 	size_t npos = 10;
 	n = s.rfind(c, npos);//npos<s.size();否则会发生访问越界
 	//size_t rfind (char c, size_t pos =0)const//pos是缺省参数, 默认为0
 	//从字符串pos位置开始往前找字符c
 	//找到字符返回字符串中的下标,找不到返回-1, 因为返回值类型size_t所以是4294967295
 	n != (size_t)-1 ? cout << c << "在字符串s中下标为" << n << "的位置\n" :
 		cout << c << "不在从下标" << npos << "位置开始往前的字符串中\n";
 	string s3 = s.substr(pos, npos);//npos<s.size(), pos>=0, npos-pos>=0;
 	//pos为缺省参数
 	//string substr(size_t pos = 0, size_t n= npos)const
 	//在str中从pos位置开始，截取n个字符，然后将其返回
 	cout << "s3:" << s3 << endl;
 	system("pause");
 	system("cls");
 }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 3][]

> 注意 :
> 
> 在string尾部追加字符时，s.push\_back('c') , s.append(1, 'c') , s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
> 
> 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve()函数把空间预留好, 这样就不会出现后期操作中频繁扩容,导致效率降低的情况发生

**5. string类非成员函数(友元函数)**

<table> 
 <thead> 
 <tr> 
 <th style="text-align:center;width:158px;">函数名称</th> 
 <th style="text-align:center;width:401px;">重载的函数</th> 
 <th style="text-align:center;width:290px;">函数功能</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <th style="text-align:center;width:158px;">operator+</th> 
 <td style="width:401px;"> string operator+ (const string&amp; lhs, const string&amp; rhs); string operator+ (const string&amp; lhs, const char* &nbsp; rhs); string operator+ (const char* &nbsp; lhs, const string&amp; rhs); string operator+ (const string&amp; lhs, char rhs); string operator+ (char lhs, const string&amp; rhs);&nbsp; </td> 
 <td style="width:290px;"> 返回字符(串)+字符(串) 此函数效率较低 </td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:158px;">operator&lt;&lt;</th> 
 <td style="width:401px;">ostream&amp; operator&lt;&lt; (ostream&amp; os, const string&amp; str);</td> 
 <td style="width:290px;">输出运算符重载,&nbsp;打印字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:158px;">operator&gt;&gt;</th> 
 <td style="width:401px;">istream&amp; operator&gt;&gt; (istream&amp; is, string&amp; str);</td> 
 <td style="width:290px;">输入运算符重载,&nbsp;输入字符串</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:158px;">getline</th> 
 <td style="width:401px;">istream&amp; getline (istream&amp; is, string&amp; str, char delim); istream&amp; getline (istream&amp; is, string&amp; str);&nbsp;</td> 
 <td style="width:290px;">获取一行字符串, char delim, 是结束符标识.</td> 
 </tr> 
 <tr> 
 <th style="text-align:center;width:158px;">relational operators</th> 
 <td style="width:401px;"> bool operator== (const string&amp; lhs, const string&amp; rhs); bool operator== (const char* &nbsp; lhs, const string&amp; rhs); bool operator== (const string&amp; lhs, const char* &nbsp; rhs);&nbsp; bool operator!= (const string&amp; lhs, const string&amp; rhs); bool operator!= (const char* &nbsp; lhs, const string&amp; rhs); bool operator!= (const string&amp; lhs, const char* &nbsp; rhs); bool operator&lt; &nbsp;(const string&amp; lhs, const string&amp; rhs); bool operator&lt; &nbsp;(const char* &nbsp; lhs, const string&amp; rhs); bool operator&lt; &nbsp;(const string&amp; lhs, const char* &nbsp; rhs); bool operator&lt;= (const string&amp; lhs, const string&amp; rhs); bool operator&lt;= (const char* &nbsp; lhs, const string&amp; rhs); bool operator&lt;= (const string&amp; lhs, const char* &nbsp; rhs); bool operator&gt; &nbsp;(const string&amp; lhs, const string&amp; rhs); bool operator&gt; &nbsp;(const char* &nbsp; lhs, const string&amp; rhs); bool operator&gt; &nbsp;(const string&amp; lhs, const char* &nbsp; rhs); bool operator&gt;= (const string&amp; lhs, const string&amp; rhs); bool operator&gt;= (const char* &nbsp; lhs, const string&amp; rhs); bool operator&gt;= (const string&amp; lhs, const char* &nbsp; rhs); </td> 
 <td style="width:290px;"> 比较两个字符串 string和char*比较 char*和string比较 string和string比较 &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

--------------------

## string类(实现常用接口) ##

**string.h**

#pragma once
 #define _CRT_SECURE_NO_WARNINGS
 #include<iostream>
 #include<string>
 #include<cstring>
 #include<cassert>
 using namespace std;
 class String {
 	size_t m_capacity;
 	char* m_data;
 	size_t m_size;
 public:
 	typedef char* Iterator;
 	//using Iterator = typename String::Iterator;
 	String();
 	String(const String&);
 	String(const char*);
 	String(size_t, char);
 	String(const String&, size_t);
 	String& operator=(const String&);
 	String& operator=(const char*);
 	template <class InputIterator>
 	String(InputIterator begin, InputIterator end) :m_size(0)
 		, m_capacity(15)
 		, m_data(new char[m_capacity])
 	{
 		reserve(end - begin);
 		m_size = end - begin;
 		strncpy(m_data, begin, end - begin);
 	}
 	~String();
 	Iterator begin()const;
 	Iterator end()const;
 	size_t size() const;
 	size_t length() const;
 	size_t capacity() const;
 	bool empty() const;
 	void clear();
 	void resize(size_t n, const char c = ' ');
 	void reserve(size_t res_arg);
 
 	char& operator[] (size_t pos) const;
 	char& operator[] (size_t pos);
 
 	void push_back(const char c);
 	void pop_back(const char c);
 	String& append(const char* s);
 	String& append(size_t n, const char c);
 	String& append(const String& s);
 	template <class InputIterator>
 	String& append(InputIterator first, InputIterator last) {
 		int size = last - first + m_size;
 		reserve(size);
 		strncpy(m_data + m_size, first, last - first);
 		m_size = size;
 		return *this;
 	}
 	const char* c_str()const;
 	size_t find(const char c, size_t pos = 0)const;
 	size_t find(const char* c, size_t pos = 0)const;
 	size_t find(const String& t, size_t pos = 0)const;
 	size_t rfind(const char c, size_t pos = 0)const;
 	size_t rfind(const char* s, size_t pos = 0)const;
 	size_t rfind(const String& t, size_t pos = 0)const;
 	String substr(size_t pos = 0, size_t n = 0)const;
 	String& operator+=(const char c);
 	String& operator+=(const String& s);
 	String& operator+=(const char* s);
 	friend String operator+(const char* s, const String& t);
 	String operator+(const char* s)const;
 	String operator+(const String& t)const;
 
 	bool operator<(const String& t)const;
 	bool operator>(const String& t)const;
 	bool operator<=(const String& t)const;
 	bool operator>=(const String& t)const;
 	bool operator==(const String& t)const;
 	bool operator!=(const String& t)const;
 
 	bool operator<(const char* s)const;
 	bool operator>(const char* s)const;
 	bool operator<=(const char* s)const;
 	bool operator>=(const char* s)const;
 	bool operator==(const char* s)const;
 	bool operator!=(const char* s)const;
 
 	friend bool operator<(const char* t1, const String& t2);
 	friend bool operator>(const char* t1, const String& t2);
 	friend bool operator<=(const char* t1, const String& t2);
 	friend bool operator>=(const char* t1, const String& t2);
 	friend bool operator==(const char* t1, const String& t2);
 	friend bool operator!=(const char* t1, const String& t2);
 	friend istream& operator>>(istream& is, String& t);
 	friend ostream& operator<<(ostream& os, const String& t);
 	friend istream& getline(istream& is, String& str, char n);
 	friend istream& getline(istream& is, String& str);
 };

**string.cpp**

#include "string.h"
 String::Iterator String::begin()const {
 	return m_data;
 }
 String::Iterator String::end() const{
 	return m_data + m_size;
 }
 String::String() :m_size(0),
 				m_capacity(15),
 				m_data(new char[m_capacity]) 
 {
 	memset(m_data, 0, m_capacity);
 }
 String::String(const String& t):m_size(0)
 							,m_capacity(15)
 							,m_data(new char[m_capacity])
 {
 	if (this == &t) {
 		return;
 	}
 memset(m_data, 0, m_capacity);
 	reserve(t.m_capacity);
 	m_size = t.m_size;
 	m_capacity = t.m_capacity;
 	strncpy(m_data, t.m_data, m_size);
 }
 String::String(const char* t) :m_size(0)
 							, m_capacity(15)
 							, m_data(new char[m_capacity]) 
 {
 	if (t == nullptr) {
 		assert(false);
 	}
 	size_t size = strlen(t);
 	reserve(size);
 	m_size = size;
 	strcpy(m_data, t);
 }
 String::String(size_t n, char c) :m_size(0)
 								, m_capacity(15)
 								, m_data(new char[m_capacity])
 {
 	reserve(n);
 	m_size = n;
 	memset(m_data, c, n);
 }
 String::String(const String& t, size_t n) :m_size(0)
 										, m_capacity(15)
 										, m_data(new char[m_capacity])
 {
 	reserve(n);
 	m_size = n;
 	strncpy(m_data, t.m_data, n);
 }
 String::~String() {	
 	if (m_data) {
 		delete[]m_data;
 	}
 	m_data = nullptr;
 	m_size = 0;
 	m_capacity = 0;
 }
 String& String::operator=(const String& t) {
 	if (this == &t) {
 		return *this;
 	}
 	reserve(t.m_capacity);
 	strcpy(m_data, t.m_data);
 	m_size = t.m_size;
 	return *this;
 }
 String& String::operator=(const char* s) {
 	if (s == nullptr) {
 		assert(false);
 	}
 	if (!strcmp(m_data, s)) {
 		return *this;
 	}
 	size_t size = strlen(s) + m_size;
 	reserve(size);
 	m_size = size;
 	strcpy(m_data, s);
 	return *this;
 }
 size_t String::size() const {
 	return m_size;
 }
 size_t String::length() const {
 	return m_size;
 }
 size_t String::capacity() const {
 	return m_capacity;
 }
 bool String::empty() const {
 	return m_size == 0;
 }
 void String::clear() {
 	m_size = 0;
 }
 void String::resize(size_t n, const char c) {
 	if (n > m_size) {
 		size_t m = m_size;
 		reserve(n);
 		m_size = n;
 		/*for (size_t i = m - 1; i < m_size; ++i) {
 			m_data[i] = c;
 		}*/
 		memset(m_data + m, c, m_capacity - m);
 	}
 }
 void String::reserve(size_t res_arg = 0) {
 	if (res_arg > m_capacity) {
 		m_capacity = (res_arg / m_capacity + 1) * 16 - 1;
 		m_data = (char*)realloc(m_data, m_capacity);
 		memset(m_data + m_size, 0, m_capacity - m_size);
 	}
 }
 
 char& String::operator[] (size_t pos) const {
 	return m_data[pos];
 }
 char& String::operator[] (size_t pos) {
 	return m_data[pos];
 }
 void String::push_back(const char c) {
 	reserve(m_size);
 	m_data[m_size++] = c;
 }
 void String::pop_back(const char c) {
 	if (m_size) {
 		--m_size;
 	}
 }
 String& String::append(const char* s) {
 	if (s == nullptr) {
 		assert(false);
 	}
 	int size = strlen(s) + m_size;
 	reserve(size);
 	strcpy(m_data + m_size, s);
 	m_size = size;
 	return *this;
 }
 String& String::append(size_t n, const char c) {
 	while (n--) {
 		push_back(c);
 	}
 	return *this;
 }
 String& String::append(const String& str) {
 	int size = str.m_size + m_size;
 	reserve(size);
 	strncpy(m_data + m_size, str.m_data, str.m_size);
 	m_size = size;
 	return *this;
 }
 String& String::operator+=(const String&str) {
 	int size = str.m_size + m_size;
 	reserve(size);
 	strncpy(m_data + m_size, str.m_data, str.m_size);
 	m_size = size;
 	return *this;
 }
 String& String::operator+=(const char* s) {
 	if (s == nullptr) {
 		assert(false);
 	}
 	int size = strlen(s) + m_size;
 	reserve(size);
 	strcpy(m_data + m_size, s);
 	m_size = size;
 	return *this;
 }
 String& String::operator+=(const char c) {
 	push_back(c);
 	return *this;
 }
 String operator+(const char* s, const String& t) {
 	if (s == nullptr) {
 		assert(false);
 	}
 	String res;
 	res = s;
 	int size = res.m_size + t.m_size;
 	res.reserve(size);
 	strncpy(res.m_data + res.m_size, t.m_data, t.m_size);
 	res.m_size = size;
 	return res;
 }
 
 String String::operator+(const char* s)const {
 	if (s == nullptr) {
 		assert(false);
 	}
 	String res = *this;
 	int size = strlen(s) + m_size;
 	res.reserve(size);
 	strcpy(res.m_data + res.m_size, s);
 	res.m_size = size;
 	return res;
 }
 String String::operator+(const String& t)const {
 	String res = *this;
 	int size = res.m_size + t.m_size;
 	res.reserve(size);
 	strncpy(res.m_data + res.m_size, t.m_data, t.m_size);
 	res.m_size = size;
 	return res;
 }
 const char* String::c_str()const {
 	return m_data;
 }
 size_t String::find(const char c, size_t pos)const {
 	if (pos < 0 || pos >= m_size) {
 		return -1;
 	}
 	char* tmp = strchr(m_data + pos, c);
 	if (tmp) {
 		return tmp - m_data;
 	}
 	else {
 		return -1;
 	}
 }
 size_t String::find(const char* c, size_t pos) const {
 	if (c == nullptr) {
 		assert(false);
 	}
 	if (pos < 0 || pos >= m_size) {
 		return -1;
 	}
 	char* tmp = strstr(m_data + pos, c);
 	if (tmp) {
 		return tmp - m_data;
 	}
 	else {
 		return -1;
 	}
 }
 size_t String::find(const String& t, size_t pos)const {
 	if (pos < 0 || pos >= m_size) {
 		return -1;
 	}
 	char* tmp = strstr(m_data + pos, t.m_data);
 	if (tmp) {
 		return tmp - m_data;
 	}
 	else {
 		return -1;
 	}
 }		 
 size_t String::rfind(const char c, size_t pos)const{
 	char* tmp = nullptr;
 	strncpy(tmp, m_data, pos);
 	char* m = nullptr;
 	if (tmp) {
 		m = strchr(tmp, c);
 	}
 	if (m) {
 		return m - tmp;
 	}
 	else {
 		return -1;
 	}
 }		 
 size_t String::rfind(const char* s, size_t pos)const {
 	if (s == nullptr) {
 		assert(false);
 	}
 	char* tmp = nullptr;
 	strncpy(tmp, m_data, pos);
 	char* m = nullptr;
 	if (tmp) {
 		m = strstr(tmp, s);
 	}
 	if (m) {
 		return m - tmp;
 	}
 	else {
 		return -1;
 	}
 }
 size_t String::rfind(const String& t, size_t pos)const {
 	char* tmp = new char[pos + 1];
 	tmp[pos] = 0;
 	strncpy(tmp, m_data, pos);
 	char* m = nullptr;
 	if (tmp) {
 		m = strstr(tmp, t.c_str());
 	}
 	if (m) {
 		return m - tmp;
 		delete[]tmp;
 	}
 	else {
 		return -1;
 		delete[]tmp;
 	}
 }
 String String::substr(size_t pos, size_t n)const {
 	String res;
 	if (pos > m_size)return res;
 	if (pos + n > m_size) {
 		n = m_size - pos;
 	}
 	res.reserve(n);
 	res.m_size = n;
 	strncpy(res.m_data, m_data + pos, n);
 	return res;
 }
 istream& operator>>(istream& is, String& t) {
 	char ch;
 	t.m_size = 0;
 	is >> ch;
 	while (ch != '\n') {
 		t.push_back(ch);
 		ch = getchar();
 	}
 	return is;
 }
 ostream& operator<<(ostream& os, const String& t) {
 	for (auto i : t) { 
 		os << i;
 	}
 	return os;
 }
 istream& getline(istream& is, String& t, char n) {
 	char ch;
 	t.m_size = 0;
 	is >> ch;
 	while (ch != n) {
 		t.push_back(ch);
 		ch = getchar();
 	}
 	return is;
 }
 istream& getline(istream& is, String& t) {
 	char ch;
 	t.m_size = 0;
 	is >> ch;
 	while (ch != '\n') {
 		t.push_back(ch);
 		ch = getchar();
 	}
 	return is;
 }
 
 bool String::operator<(const String& t)const {
 	size_t n;
 	m_size < t.m_size ? n = m_size : n = t.m_size;
 	return strncmp(m_data, t.m_data, n) < 0;
 }
 bool String::operator>(const String& t)const {
 	size_t n;
 	m_size < t.m_size ? n = m_size : n = t.m_size;
 	return strncmp(m_data, t.m_data, n) > 0;
 }
 bool String::operator<=(const String& t)const {
 	//size_t n;
 	//m_size < t.m_size ? n = m_size : n = t.m_size;
 	//return strncmp(m_data, t.m_data, n) < 0 || m_size == t.m_size && !strncmp(m_data, t.m_data, n);
 	return *this < t || *this == t;
 }
 bool String::operator>=(const String& t)const {
 	//size_t n;
 	//m_size < t.m_size ? n = m_size : n = t.m_size;
 	//return strncmp(m_data, t.m_data, n) > 0 || m_size == t.m_size && !strncmp(m_data, t.m_data, n);
 	return *this > t || *this == t;
 }
 bool String::operator==(const String& t)const {
 	size_t n;
 	m_size < t.m_size ? n = m_size : n = t.m_size;
 	return m_size == t.m_size && !strncmp(m_data, t.m_data, n);
 }
 bool String::operator!=(const String& t)const {
 	//size_t n;
 	//m_size < t.m_size ? n = m_size : n = t.m_size;
 	//return m_size != t.m_size || !strncmp(m_data, t.m_data, n);
 	return !(*this == t);
 }
 
 bool String::operator<(const char* s)const {
 	if (s == nullptr) {
 		assert(false);
 	}
 	size_t n = strlen(s);
 	m_size < n ? n = m_size : n;
 	return strncmp(m_data, s, n) < 0;
 }
 bool String::operator>(const char* s)const {
 	if (s == nullptr) {
 		assert(false);
 	}
 	size_t n = strlen(s);
 	m_size < n ? n = m_size : n;
 	return strncmp(m_data, s, n) > 0;
 }
 bool String::operator<=(const char* s)const{
 	if (s == nullptr) {
 		assert(false);
 	}
 	return *this < s || *this == s;
 }
 bool String::operator>=(const char* s)const{
 	if (s == nullptr) {
 		assert(false);
 	}
 	return *this > s || *this == s;
 }
 bool String::operator==(const char* s)const{
 	if (s == nullptr) {
 		assert(false);
 	}
 	size_t L = strlen(s);
 	size_t n;
 	m_size < L ? n = m_size : n = L;
 	return m_size == strlen(s) && !strncmp(m_data, s, n);
 }
 bool String::operator!=(const char* s)const{
 	if (s == nullptr) {
 		assert(false);
 	}
 	return !(*this == s);
 }
 
 bool operator<(const char* t1, const String& t2) {
 	if (t1 == nullptr) {
 		assert(false);
 	}
 	/*size_t n;
 	size_t size = strlen(t1);
 	size < t2.m_size ? n = size : n = t2.m_size;
 	return strncmp(t1, t2.m_data, n) < 0;*/
 	return t2 > t1;
 }
 bool operator>(const char* t1, const String& t2) {
 	if (t1 == nullptr) {
 		assert(false);
 	}
 	/*size_t n;
 	size_t size = strlen(t1);
 	size < t2.m_size ? n = size : n = t2.m_size;
 	return strncmp(t1, t2.m_data, n) > 0;*/
 	return t2 < t1;
 }
 bool operator<=(const char* t1, const String& t2){
 	if (t1 == nullptr) {
 		assert(false);
 	}
 	return t2 >= t1;
 	/*size_t n;
 	size_t size = strlen(t1);
 	size < t2.m_size ? n = size : n = t2.m_size;
 	return strncmp(t1, t2.m_data, n) < 0 || size == t2.m_size && !strncmp(t1, t2.m_data, n);*/
 }
 bool operator>=(const char* t1, const String& t2){
 	if (t1 == nullptr) {
 		assert(false);
 	}
 	return t2 <= t1;
 	/*size_t n;
 	size_t size = strlen(t1);
 	size < t2.m_size ? n = size : n = t2.m_size;
 	return strncmp(t1, t2.m_data, n) > 0 || size == t2.m_size && !strncmp(t1, t2.m_data, n);*/
 }
 bool operator==(const char* t1, const String& t2){
 	if (t1 == nullptr) {
 		assert(false);
 	}
 	/*size_t n;
 	size_t size = strlen(t1);
 	size < t2.m_size ? n = size : n = t2.m_size;
 	return size == t2.m_size && !strncmp(t1, t2.m_data, n);*/
 	return t2 == t1;
 }
 bool operator!=(const char* t1, const String& t2){
 	if (t1 == nullptr) {
 		assert(false);
 	}
 	//return !(t1 == t2);
 	return !(t2 == t1);
 }

**test.h**

#pragma once
    #include"string.h"
    void test1();
    void test2();
    void test3();
    void test4();
    void test5();

**test.cpp**

#include"test.h"
 void test1() {
 	cout << "test1()\n\n";
 	String s;
 	s = "bcd";
 	String s1;
 	s1 = "abcdefghijklmn";
 	cout << s.size() << endl;
 	cout << s.capacity() << endl;
 	s.resize(30, 'c');
 	cout << s.capacity() << endl;
 	s.empty() ? cout << "s为空\n" : cout << "s不为空\n";
 	cout << s1.find('c') << endl;
 	cout << s1.find("nop") << endl;
 	cout << s1.find(s) << endl;
 	cout << s << endl;
 	s.clear();
 	s.empty() ? cout << "s为空\n" : cout << "s不为空\n";
 	cout << s << endl;
 	system("pause");
 	system("cls");
 }
 void test2() {
 	cout << "test2()\n\n";
 	String s;
 	s = "bcd";
 	String s1;
 	s1 = "abcdefghijklmn";
 	String s2("rst");
 	String s3(s2);
 	String s4(5, 'z');
 	cout << "s: " << s << endl;
 	cout << "s1: " << s1 << endl;
 	cout << "s2 :" << s2 << endl;
 	cout << "s3 :" << s3 << endl;
 	cout << "s4 :" << s4 << endl;
 	s1 += 'o';
 	cout << "s1: " << s1 << endl;
 	s1 += "pq";
 	cout << "s1: " << s1 << endl;
 	s1 += s2;
 	cout << "s1: " << s1 << endl;
 	s1 = "字母" + s1;
 	cout << "s1: " << s1 << endl;
 	s1 = s1 + "uv";
 	cout << "s1: " << s1 << endl;
 	String s5 = "wx";
 	s1 = s1 + s5;
 	cout << "s1: " << s1 << endl;
 	const char* c_s = s1.c_str();
 	cout << "c_S: ";
 	for (size_t i = 0; i < s1.size(); ++i) {
 		cout << c_s[i];
 	}
 	cout << endl;
 	String::Iterator begin = s1.begin();
 	String::Iterator end = s1.end();
 	String s6(s1.begin(), s1.end());
 	String s8;
 	s8.append(s2.begin(), s2.end());
 	cout << "s6: " << s6 << endl;
 	cout << "s8: " << s8 << endl;
 	system("pause");
 	system("cls");
 }
 void test3() {
 	cout << "test3()\n\n";
 	String s1;
 	s1 = "abcdefghijklmn";
 	const char* c_s2 = "lmn";
 	const char* c_s3 = "abcf";
 	const char* c_s4 = "ghi";
 	String s2(c_s2);
 	String s3(c_s3);
 	String s4(c_s4);
 	cout << "s1 :" << s1 << endl;
 	cout << "s2 :" << s2 << endl;
 	cout << "s3 :" << s3 << endl;
 	cout << "s4 :" << s4 << endl;
 	cout << "c_s2 :" << c_s2 << endl;
 	cout << "c_s3 :" << c_s3 << endl;
 	cout << "c_s4 :" << c_s4 << endl;
 	char c1 = 'd';
 	char c2 = 'z';
 	cout << s1.find(c1) << endl;
 	cout << s1.find(c2) << endl;
 	cout << s1.find(c_s2) << endl;
 	cout << s1.find(c_s3) << endl;
 	cout << s1.find(c_s4) << endl;
 	cout << s1.find(s2) << endl;
 	cout << s1.find(s3) << endl;
 	cout << s1.find(s4) << endl;
 	cout << s1.rfind(s2, s1.size()) << endl;
 	cout << s1.rfind(s3, s1.size()) << endl;
 	cout << s1.rfind(s4, s1.size()) << endl;
 
 	cout << s1.substr(10, 10) << endl;
 	String s10;
 	s10 = "123456789";
 	cout << s10.substr(3, 7) << endl;
 	cout << s10.substr(10, 7) << endl;
 	system("pause");
 	system("cls");
 }
 void test4() {
 	cout << "test4()\n\n";
 	String s1 = "abcde";
 	String s2 = "abc";
 	String s3 = "cde";
 	String s4(s1);
 	cout << "s1: " << s1 << endl;
 	cout << "s2: " << s2 << endl;
 	cout << "s3: " << s3 << endl;
 	cout << "s4: " << s4 << endl;
 	s1 < s2 ? cout << "s1<s2\n" : cout << "s1>=s2\n";
 	s3 > s2 ? cout << "s3>s2\n" : cout << "s3<=s2\n";
 	s1 <= s2 ? cout << "s1<=s2\n" : cout << "s1>s2\n";
 	s3 >= s2 ? cout << "s3>=s2\n" : cout << "s3<s2\n";
 	s1 == s4 ? cout << "s1==s4\n" : cout << "s1!=s4\n";
 	s1 != s2 ? cout << "s1!=s2\n" : cout << "s1==s2\n";
 	const char* c_s1 = s1.c_str();
 	const char* c_s2 = s2.c_str();
 	const char* c_s3 = s3.c_str();
 	const char* c_s4 = s4.c_str();
 	cout << "c_s1: " << c_s1 << endl;
 	cout << "c_s2: " << c_s2 << endl;
 	cout << "c_s3: " << c_s3 << endl;
 	cout << "c_s4: " << c_s4 << endl;
 	s1 < c_s2 ? cout << "s1<c_s2\n" : cout << "s1>=c_s2\n";
 	s3 > c_s2 ? cout << "s3>c_s2\n" : cout << "s3<=c_s2\n";
 	s1 <= c_s2 ? cout << "s1<=s2\n" : cout << "s1>s2\n";
 	s3 >= c_s2 ? cout << "s3>=s2\n" : cout << "s3<s2\n";
 	s1 == c_s4 ? cout << "s1==c_s4\n" : cout << "s1!=c_s4\n";
 	s1 != c_s2 ? cout << "s1!=c_s2\n" : cout << "s1==c_s2\n";
 	cout << "\n\n\n";
 	c_s2 > s1 ? cout << " c_s2>s1\n" : cout << "c_s2<=s1\n";
 	c_s2 < s3 ? cout << " c_s2<s3\n" : cout << "c_s2>=s3\n";
 	c_s2 >= s1 ? cout << "c_s2>=s1\n" : cout << "c_s2<s1\n";
 	c_s2 <= s3 ? cout << "c_s2<=s3\n" : cout << "c_s2>s3\n";
 	c_s4 == s1 ? cout << "c_s4==s1\n" : cout << "c_s4!=s1\n";
 	c_s2 != s1 ? cout << "c_s2!=s1\n" : cout << "c_s2==s1\n";
 	system("pause");
 	system("cls");
 }
 void test5() {
 	cout << "test5()\n\n";
 	String s1;
 	cout << "请输入s1\n";
 	cin >> s1;
 	cout << "s1: " << s1 << endl;
 	String s2;
 	cout << "请输入s2\n";
 	getline(cin, s2);
 	cout << "s2: " << s2 << endl;
 	cout << "请输入s2, #结束\n";
 	getline(cin, s2, '#');
 	cout << "s2: " << s2 << endl;
 	system("pause");
 	system("cls");
 }

**main.cpp**

#include"string.h"
    #include"test.h"
    int main() {
    	test1();
    	test2();
    	test3();
    	test4();
    	test5();
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 7][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 8][]

[vector]: https://blog.csdn.net/qq_41071068/article/details/101421847#vector%E7%9A%84%E5%B8%B8%E7%94%A8%E6%8E%A5%E5%8F%A3
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5714f2db735141f38679a79078477f2e.png
[Link 1]: http://c.biancheng.net/c/80/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/73b9da49af454c188b95c8f0d5e6886d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ccbc909357564a22a3e4559c9dccf468.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b6dfae81ddbe4ac0ab13f65f544b81c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4bbbf88cb1524afeb457f8bf87137ceb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/54043be3e76d4ce084a65f343b26f0ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/890107e167cd4046bc34825b38bd3a9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20190919223336664.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4706600103f8493d901ecac1442a0c8c.png