STL--string类--string类的了解--string类的常用接口实现--string类的6种初始化方式--常见构造--迭代器--string类对象的访问--容量操作--修改操作

傷城~ 2022-11-10 05:36 3阅读 0赞

### String类 ###

*  目录
 *  string类的常用接口实现:
 *   *   *   *  一.string类的6种初始化方式
             *   *  1.创建空的string对象
                 *  2.将括号内部的字符串进行复制
                 *  3.通过内部的字符串创建一个对象
                 *  4.通过一个字符串的部分内容来创建一个新的字符串对象
                 *  5.获取你输入字符串的前几个形成新的字符串
                 *  6.创建一个字符对象,看有几个括号内的字符
                 *  7.常用的简单构造
             *  二.string类对象的常见构造
             *   *  1.const对象
                 *  2.非const对象
             *  三.迭代器
             *   *  1.迭代器的特点:
                 *  2.类型:
                 *  正向迭代器
                 *  反向迭代器
             *  四.string类对象的访问
             *   *  1)for循环+operator\[\]
                 *  2)迭代器
                 *  3)范围for
             *  五.string类对象的容量操作
             *   *  size
                 *  capacity
                 *  resize
                 *  reserve
                 *  clear
                 *  shrink\_to\_fit
             *  六.string类对象的修改操作
             *   *  1)operator+=
                 *  2)push\_back
                 *  3)append
                 *  4)insert

# 目录 #

# string类的常用接口实现: #

#### 一.string类的6种初始化方式 ####

##### 1.创建空的string对象 #####

**string();**

//创建一个空的string类
    string 	str;		//NULL

##### 2.将括号内部的字符串进行复制 #####

**string(const string& str);**

//赋值括号内部的字符串内容,并赋予copy
    string copy(str);		//NULL

##### 3.通过内部的字符串创建一个对象 #####

*string(const char s);*\*

//创建一个字符串为"abc"的str2字符串
    string str2("abc");		//abc

##### 4.通过一个字符串的部分内容来创建一个新的字符串对象 #####

**string(const string& str,size\_t pos,size\_t len=npos);**

//从str2的第二个字符开始复制两个字符创建成新的substr字符串
    string substr(str2,1,2);		//bc

##### 5.获取你输入字符串的前几个形成新的字符串 #####

*string(const char s,size\_t n);*\*

//取我所输入的字符串的前5个形成新的str3字符串
    string str3("12345678",5);		//12345

##### 6.创建一个字符对象,看有几个括号内的字符 #####

**string(size\_t n, char c);**

//取10个括号内的'b'形成新的字符串str4
    string str4(10,'b');		//bbbbbbbbbb

##### 7.常用的简单构造 #####

这一种是最常见的,相信大家也会,不过多解释.

string str5="fighting!";

这里的str5对应的字符串可以直接改变,在如果加有const 的时候,不能发生变化.

#### 二.string类对象的常见构造 ####

##### 1.const对象 #####

**const char& operator\[\](size\_t pos) const**

void test(){ 
    
    const string str="12345";
    	  string str2 = "12345";
    
    //1.可以读取其中的字符串(通过调试)
    	char ch = str[3];
    	const char& ref = str[3];
    
    //2.不可以修改其中的字符串(这里是const形式的)
    	str[3] = 'f';
    	str[3] = 'a';	//修改的话,这里会报错
    
    }

##### 2.非const对象 #####

**char& operator\[\](size\_t pos) const**

void test(){ 
    	
    	const string str="12345";	//简单的赋值
    	string str2 = "12345";
    
    	char& ref1 = str2[3];	//构造函数
    	str2[3] = 'a';		//在这里改变单个字符的值的时候是可以通过的
    	
    	str2.at(3) = 'b';	//在这里可以直接运用at对对应的位置字符的改变
    						//string类.at(对应数组的位置)='要改动的值'
    }

**越界:**  
1.**\[ \]越界**: 报断言错误

char ch=str2[1000];

2.**at越界**:抛出异常

char ch2=str2.at(10);

#### 三.迭代器 ####

##### 1.迭代器的特点: #####

1)迭代器的使用方法和指针的类似

2)访问数据:通过解引用来完成: \*,->

3)迭代器移动:++移动到下一个元素,–移动到上一个

4)位置的判断:支持!=,==

5)其中在有些容器中存在反向迭代器

##### 2.类型: #####

1)**begin迭代器**:指向第一个元素  
2)**end迭代器**:指向最后一个元素的末尾  
3)**rbegin迭代器**:指向最后一个元素的位置  
4)**rend迭代器**:指向第一个元素的前一个位置

##### 正向迭代器 #####

**string::iterator 变量名=str.+对应的迭代器**

void test(){ 
    
    	string str = "12345";
    	//起始位置的迭代器
    	string::iterator it = str.begin();		//描述起始位置
    	for (; it != str.end(); ++it){ 	//利用一个for循环将其中的所有值进行输出
    		
    		//迭代器的解引用
    		cout << *it <<" ";		//迭代器需要进行解引用
    
    		//可以通过迭代器对内容进行修改
    		*it = 'a';			//未有过const的迭代器可以对其中的值进行修改
    
    	}
    	const string str2 = "abcde";		//这里是一个不能被修改的string 类
    	//只读的操作
    	string::const_iterator it2 = str2.begin();		//在调用的时候也是和const相关的
    	while (it2!=str2.end()){ 
    		
    		cout << *it2 << " ";		//解引用进行循环
    		//只读迭代器,不可以发生修改,因为是const
    		//*it2 = 's'; //定义了const的类型不能修改其中的值
    		++it2;		//迭代器向下一个元素进行移动
    	}
    }

##### 反向迭代器 #####

**string::reverse\_iterstor +变量名=str.+迭代器类型**

void test(){ 
    
    	string str = "12345";
    	//最后一个元素的位置
    	string::reverse_iterator it = str.rbegin();	//从最后一个元素的位置开始
    	while (it != str.rend()){ 		//当it指向第一个元素之前的元素的时候,循环结束
    		
    		cout << *it << " ";	//54321 //所以这里打印出来的就是相反的
    		//反向移动
    		*it = 'a';
    		++it;		//向后移动
    	}
    
    
    	//只读的反向迭代器
    	const string str2 = "abcde";
    
    	string::const_reverse_iterator it2 = str2.rbegin();
    	while (it2 != str2.rend()){ 
    		
    		cout << *it2 << " ";
    		//只读迭代器:const不可以发生修改
    		//*it2 = "d";
    		++it2;
    	}
    }

关于迭代器这里的只是主要就是记住其中的特点,还有就是记住如果加了const类型名,则就变为了只读,不可以修改其中的内容.

#### 四.string类对象的访问 ####

##### 1)for循环+operator\[\] #####

void test(){ 
    	
    	string str = "12345";
    	for (size_t i = 0; i < str.size(); ++i){ 
    		
    		cout << str[i] << " ";
    		str[i] = 'a';
    	}
    	cout << endl;
    }

##### 2)迭代器 #####

这里的迭代器在上面已经实现过了,大家具体看上面.

##### 3)范围for #####

void test(){ 
    	
    	//==范围for:访问范围确定的序列
    	int arr[] = {  1, 2, 3, 4, 5 };
    	for (const auto& e : arr){ 
    		
    		cout << e << " ";
    	}
    	cout << endl;
    
    	for (auto& e : arr){ 
    		
    		e = 10;
    	}
    		
    
    	string str="12345";		//简单定义一个字符串
    
    	for(auto& ch:str){ 		//取到对应的空间
    	//范围for:实际上就是通过迭代器进行实现的
    	// 支持迭代器访问的自定义类型都可以支持范围for
    	
    		cout<<ch<<" ";		//输出,因为引用了,所以不需要解引用
    		ch='a';
    	}
    }

#### 五.string类对象的容量操作 ####

##### size #####

\----用来查看有效字符的个数

cout << str.size() << endl;		//直接输出有效字符个数

##### capacity #####

\----当前string中最多可以存放的元素个数

int cap = str.capacity();	//定义一个整型变量将其对应的最多存放元素个数的值赋予

##### resize #####

\----修改有效字符的个数

str.resize(20);		//直接将有效字符的个数修改为20,多则补'\0',少则不补

##### reserve #####

\----修改容量:只进行容量的增加,不能减小

str.reserve(60);	//修改容量为60,只能改大

##### clear #####

\----清空有效字符

str.clear();		//清理完所有的有效字符

##### shrink\_to\_fit #####

\----调整容量的大小,将容量和实际的字符大小调整在差不多同一个量级

str.shrink_to_fit();		//将'\0'这样的得无用的进行清理,只保留有效的

**实现代码:**

这里的代码不过多的解释,大家自己可以看懂的,自己敲一遍,进行理解就行了.

void test(){ 
    
    
    	string  str;
    	cout << str.size() << endl;
    	
    	//====resize:修改有效字符的个数
    	//resize(n):如果有效字符个数增加,新的位置填充'\0'
    	//resize(n, ch): 如果有效字符的个数增加,则新增的位置填充ch
    	//如果size减小,则不会进行填充
    
    	//==修改有效字符的个数
    	//有效字符是按照size最终的大小来规定的,\0也有可能是有效字符
    	str.resize(10);
    
    	cout << str.size() << endl;
    
    	string str2 = "123";		//在有效元素不够的时候,像这里会填充7个\0
    	cout << str2.size() << endl;
    	str2.resize(10);
    	cout << str2.size() << endl;
    
    	str2.resize(2);		//将有效字符减少
    	cout << str2.size() << endl;
    
    	//如果有扩充空间的话,将需要填充的空间将a进行填入,就不为\0
    	str2.resize(5, 'a');	//12aaa
    
    	str2.resize(2, 'b');	//如果变小,没有需要填充的位置则没有用
    
    }
    
    //====capacity
    void test(){ 
    
    	string str = "123";
    	int sz = str.size();
    	//capacity当前string 中最多可以存放的元素个数
    	int cap = str.capacity();
    	str.resize(10);
    	sz = str.size();
    	cap = str.capacity();
    	str.resize(1);
    	sz = str.size();
    	cap = str.capacity();
    	str.resize(20);
    	//resize:当调整之后的size大于容量的时候,容量也会发生变化
    	sz = str.size();
    	cap = str.capacity();
    
    	//reserve:修改容量:只能进行容量的增加,不能减小
    	//不影响size
    	str.reserve(60);
    	sz = str.size();
    	cap = str.capacity();
    
    	str.reserve(10);
    	sz = str.size();
    	cap = str.capacity();
    
    
    	//clear: 清空有效字符 只影响size 
    	str.clear();
    	sz = str.size();
    	cap = str.capacity();
    
    }
    
    //====shrink接口
    void test(){ 
    
    	string str = "123";
    	int sz = str.size();
    	int cap = str.capacity();
    
    	//主要作用就是把将其中像'\0'这样没有作用的字符进行清理,保证每个字符都是有效的
    	str.shrink_to_fit();	
    	int sz = str.size();
    	int cap = str.capacity();
    
    }

#### 六.string类对象的修改操作 ####

##### 1)operator+= #####

\----这里是一个类似于尾插的操作,直接进行就可以了.

void test(){ 
    
    	string str;
    	string str2 = "123";
    	
    	//连续操作
    	str += str2;	//123
    	str += "abc";	//123abc
    	str += '4';		//123abc4
    	//完整形式
    	str.operator+=('5');	//123abc45
    }

##### 2)push\_back #####

\----这里也是一个类似于尾插的操作

**函数内部先进行扩容.然后利用push\_back使要插入的字符充满整个容量**

void test(){ 
    	
    	//按照1.5倍的空间进行增容
    	string str;
    	int cap = str.capacity();
    
    	//避免频繁的增容,提高代码的效率
    	//直接增容到200,就不存在过程
    	str.reserve(200);
    	
    	cout << cap << endl;
    	for (int i = 0; i < 200; ++i){ 
    		
    		str.push_back('a');				//在函数的内部,一直进行着增添a的操作,它的有效字符一直在增长
    		if (cap != str.capacity()){ 
    			
    			cap = str.capacity();
    			cout << cap << endl;
    		}
    	}
    }

##### 3)append #####

\----类似于将两个字符串进行合并的样子.

void test(){ 
    
    	string str;
    	string str2 = "123";
    
    	str.append(str2);	//123
    	//将str2中的字符由第二个向后开始插入一个
    	str.append(str2, 1, 1);		//1232
    
    	str.append("abc");	//1232abc
    	//直接将输入字符串的前六个进行连接
    	str.append("123456", 6);	//1232abc123456
    	//直接将括号内的m*5进行连接
    	str.append(5, 'm');	//1232abc123456mmmmm
    
    	char arr[] = "abcdefg";
    	str.append(arr, arr + sizeof(arr) / sizeof(arr[0]));	//1232abc123456mmmmmabcdefg 
    	str.append(str2.begin(), str2.end());	//1232abc123456mmmmmabcdefg123
    
    }

##### 4)insert #####

\----找到你想插入的位置,对有效字符进行插入

void test(){ 
    
    	string str="123";
    	string str2 = "abc";
    
    	str.insert(0, str2);	//abc123
    	//在4的位置开始插入str2中的从第二个开始插入两个
    	str.insert(4, str2, 1, 2);	//abc1bc23
    
    	str.insert(str.size(), "abc");	//abc1bc23abc
    	//从第五个开始插入后面字符串的前四个
    	str.insert(5, "12345", 4);	//abc1b1234c23abc
    	//从开始的地方开始插入两个括号内的对应字符
    	str.insert(str.begin(), 2, '0');	//00abc1b1234c23abc
    
    	str.insert(str.end(), str2.begin(), str2.end());	//00abc1b1234c23abc123
    }

今天的代码就写到这里,当然对于string类的总结还没有完善,后期会继续完善.大家一起加油!!!多敲代码!!!