【C++】string使用

文章目录

• 1、 为什么要学习string类
• 2、标准库中的string类
• • 2.1了解string类
  • 2.2string类常用的接口
  • • 2.2.1 构造和析构相关
    • 2.2.2 迭代器
    • 2.2.3 容量相关
    • 2.2.4 元素访问 && 元素遍历
    • • 元素访问
      • 元素遍历
    • 2.2.5 修改相关
    • 2.2.6 其他

1、 为什么要学习string类

1、C语言中，字符串是以’

字符串是表示字符序列的类

’结尾的一些字符的集合，为了 *** 作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问

2、在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串 *** 作函数

2、标准库中的string类 2.1了解string类

1. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型)
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于 *** 作单字节字符字符串的设计特性。
   

   
   

3. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数
4. string是表示字符串的字符串类
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来 *** 作。
   

   
   

总结：

using namespace std
1. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来 *** 作string的常规 *** 作。
   

   
   

2. string在底层实际是：basic_string模板类的别名，typedef basic_string string;
3. 不能 *** 作多字节或者变长字符的序列。
   

   
   

在使用string类时，必须包含#include头文件以及

(constructor)—构造

2.2string类常用的接口

申明：以下的所有Windows平台测试均在VS2013环境下进行，期间也会有部分功能在Linux平台下测试

2.2.1 构造和析构相关

string()

(1)string(const string& str)
默认构造函数，得到的是一个长度为0的空串

(2)拷贝构造
这是一个 sting(const string& str,size_t pos,size_t len = npos)函数，用已经存在的字符串str拷贝构造新的字符串
具体使用方式如下：

(3)从pos下标开始，长度为len
功能：使用字符串str的string(const char* s)这一部分字符串来构造新的字符串（len是一个缺省参数，默认值为npos,如果不给定，默认到字符串str的末尾）
功能演示

(4)string(const char* s,size_t n);
使用C语言中的字符串来构造新的对string对象

(5)string(size_t n,char c)
使用C语言中的字符串s中的前n个字符来构造string对象

(6)string(InputIterator first,InputIterator last)
使用n个字符c来构造string对象

(7)template

(destructor)—析构

~

 string();string& operator= (const string& str)

每个对象在生命周期结束时会自动调用该析构函数

1. operator=—赋值
   (1)string& operator= (const char* s);
   (2)string& operator= (char c);
   (3)iterator begin() | const_iterator begin() const;
   

2.2.2 迭代器

暂时理解—是一个类似于指针的玩意儿
2. begin() && end()
iterator end() | const_iterator end() const;
iterator rbegin() | const_iterator rbegin() const;
3. rbegin() && rend()
iterator rend() | const_iterator rend() const;
size_t size() const;
画图解释：

2.2.3 容量相关

1. size_t length() const;
2. 引入STL之后，为了兼容又加入了size，它是作为STL容器的属性存在的，便于符合STL的接口规则，以便用于STL的算法 ;
   size() 和length()功能完全一致，都是获取字符串的有效长度
   展示：
   

疑问：为什么string要提供两个功能完全一致的方法size()和length()呢？

原因： length是因为沿用C语言的习惯而保留下来的，string类最初只有length，size_t capacity() const

3. void resize(size_t newsize);;
   获取string对象在底层维护的顺序表的容量
   

4. void resize(size_t newsize,char c) | void reverse(size_t newcapacity = 0);
   resize—将string对象现有的有效元素个数更新为newsize个
   注意：newsize的值可以大于原来有效元素的个数，也可以小于。
   

   
   

   因此，我们在使用resize的时候要注意区分。
   

   
   

   具体情况见下图：
   
   下面我们通过代码验证上述的每个情况：
   ①验证newsize<= oldsize
   
   ②验证newsize > oldsize && newsize <= capacity
   
   ③验证newsize > olssize && newsize > capacity
   

5. Ⅱ在Linux平台下验证;
   作用：扩容，只改变容量，不会修改有效元素的个数
   假设string中原来的容量为oldcapacity,现在的参数为newcapacity
   
   验证：
   (1)newcapacity <= oldcapacity
   ①newcapacity <= oldcapacity && oldcapacity <= 15
   
   ②newcapacity <= oldcapacity && oldcapacity > 15 && newcapacity >15
   
   ③newcapacity <= oldcapacity && oldcapacity > 15 && newcapacity <=15
   
   为什么在newcapacity<=15 && oldcapacity > 15的情况下，缩小容量会变成15？
   原因分析：在string类的内部除了维护顺序表必须的三个成员以外，还有一个char array[BUF_SIZE],该数组的大小为16。
   

   
   

   具体如下图
   
   (2)newcapacity > oldcapacity
   会进行扩容，主要执行以下步骤：
   开辟新空间—>拷贝元素---->释放旧空间—>返回新空间
   
   验证string内部扩容的方式~
   Ⅰ在Windows平台下使用VS2013验证
   
   void clear()
   
   

6. char& operator[](size_t pos);
   清空有效元素，不改变空间大小
   

2.2.4 元素访问 && 元素遍历 元素访问

使用[]和at两类方法访问元素时，效果一样，只是针对于异常情况的处理方式不一样。

具体区别如下：
(1)operator[]
const char& operator[](size_t pos)const | char& at(size_t pos)
在访问越界的时候，会触发assert断言，直接终止程序

(2)at
const char& at(size_t pos) const | char& front()
在访问越界的时候，会抛出异常，用户可以对其进行捕获

总结operator[] 与at:

(3)front----C++11
const char front()const; | char& back()
C++11中引入的新方法，获取string的第一个字符
(4)back----C++11
const char back()const; | int
C++11中引入的新方法，获取string的最后一个字符

疑问：为什么这些元素访问类的函数，都会提供const和非const两份代码呢？

这个想要搞清楚，首先要明白const修饰成员函数后有哪些特性！（深入了解点这里）由于const对象不能调用非const的成员函数，所以必须提供两份代码。

不然被const修饰对象就无法调用该方法，那也就意味着无法访问string的pos处的元素，这显然是不合理的！因此，对于这种元素访问类型的方法，需要提供两份代码！

元素遍历

（1）for循环+[]访问
（2）迭代器
（3）范围for
这个比较简单，直接看代码

main ()str
{
	string ("hello");//for+[]
	for
	( int= i 0 ;< i . strsize();++ i)<<
	{
		cout [ str]i;}
	<<
	cout ; endl//迭代器
	::
	string=iterator it . strbegin();while
	( !=it . strend())<<
	{
		cout * ;it++
		it;}
	<<
	cout ; endl//范围for
	for
	( auto: e ) str<<
	{
		cout ; e}
	<<
	cout ; endlreturn
	0 ;}
string& operator+=(const string& str)

2.2.5 修改相关

1. operator+=
   string& operator+=(const char* s);—末尾追加string
   string& operator+=(const char c);----末尾追加C中的字符串
   string& append(const string& str)；—末尾追加字符
   
2. append
   ①string& append(const string& str，size_t subpos,size_t sublen);;
   功能：末尾追加一个str
   
   ② string& append(const char* s);
   功能：将str从subpos开始，长度为sublen的子串追加到调用者的末尾
   
   ③string& append(const char* s,size_t n);
   功能：在末尾追加一个C中的字符串
   
   ④string& append(size_t n,char c);
   功能：在末尾追加字符串s从0号位置开始，长度为n的子串
   
   ⑤string& append(InputIterator first,InputIterator last)
   功能：在末尾追加n个char类型的元素c
   
   ⑥template
void push_back(char c);
   功能：将迭代器first–last区间内的内容追加到字符串的末尾
   
3. push_back
   string& insert(size_t pos,const string& str);;
   功能：末尾追加一个字符c
   
4. insert
   ①string& insert(size_t pos,const string& str,size_t subpos,size_t sublen);
   功能：在pos处，插入字符串str
   
   ②string& insert(size_t pos,const char* s);
   功能：在pos处插入str从subpos开始，长度为sublen的子串
   
   ③string& insert(size_t pos,const char* s,size_t n);
   功能：在pos处插入C中的字符串s
   
   ④string& insert(size_t pos,size_t n,char c);
   功能：在pos处插入字符串s的前n个字符
   
   ⑤void insert(iterator p,size_t n,char c)
string& erase(size_t pos = 0,size_t len = npos);;
   功能：在pos或者p处插入n个字符c
   
5. erase
   ①iterator erase(iterator p);
   功能：删除从pos开始，长度为len的子串。
   

   
   

   
   注意：pos和len均为缺省参数，默认删除整个字符串
   
   ②iterator erase(iterator first，iterator last)
   功能：删除p位置的元素，返回下一个元素的位置
   
   注意：在删除字符串的最后一个位置时，返回值是非法的，无法再次被使用
   
   ③void swap(string& str);
   删除区间first–last之间的元素
   

6. swap
   const char* c_str() const;
   功能：交换两个string类型的对象，string::swap效率比全局的swap要高，在交换字符串的时候强烈建议使用string::swap
   

2.2.6 其他

1. c_str
   size_t find(const string& str,size_t pos = 0)const;;
   以C语言的方式返回字符串string
   
2. find
   ①size_t find(const char* s,size_t pos = 0)const
   功能：在目标字符串中查找str字符串出现的位置，默认从头开始查找。
   

   
   

   找到返回str首个字符在目标字符串中的位置，找不到返回npos
   
   ②size_t find(const char* s,size_t pos,size_t n)const;
   功能与上一个一致，唯一区别是这个查询的是C中的字符串
   ③size_t find(char c,size_t pos=0)const;
   功能：查询C中字符串的前n个字符
   ④size_t find_first_of(const string& str,size_t pos=0)const;;
   功能：查询字符c的位置，，哦人从0下标开始查询

3. rfind
   功能与find类似，只不过是从字符串的末尾向起始位置查找
   
4. find_first_of
   与find类似，只不过是查找第一次出现的某一个字符或字符串
   接口如下：

①size_t find_first_of(const char*s,size_t pos=0)const;

找第1次出现string str的位置，默认从头开始查找

②size_tfind_first_of(const char* s,size_t pos,size_t n)const;

找第1次出现C语言字符串s的位置，默认从头开始查找

③size_t find_first_of(char c,size_tpos=0)const;

找第1次出现C语言字符串s从pos开始，长度为n的子串的位置，

④size_t find_last_of(const string& str,size_t pos=npos)const;

找第1次出现字符c的位置，默认从起始位置开始查找

6. find_last_of
   与rfind类似，只不过是查找第一次出现的某一个字符或字符串
   接口如下：

①size_t find_last_of(const char*s,size_t pos=npos)const;

找第1次出现string str的位置，默认从末尾开始查找

②size_t find_last_of(char c,size_tpos=npos)const;

找第1次出现C语言字符串s的位置，默认从末尾开始查找 ③`size_t

find_last_of(const char* s,size_t pos,size_t n)const;`

找第1次出现C语言字符串s从pos开始，长度为n的子串的位置，

④string& substr(size_t pos,size_t len = mpos)const

找第1次出现字符c的位置，默认从末尾开始查找

8. substr
   ;
   功能：截取子串,pos为截取的起始位置，len表示截取的长度
   

ok~以上就是string容器的基本接口介绍及其使用，当然，这些也不是全部的接口，只是一些比较常用的接口！更下详细的可以参考http://www.cplusplus.com/
各位看官要是觉得有所收获，留下你们的足迹!