string类

1.为什么要学习string类

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

2.标准库中的string类

2.1string类（了解）

string的文档

总结：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string
   string;
4. 不能操作多字节或者变长字符的序列。
   在使用string类时，必须包含#include头文件以及using namespace std;
   string的补充
   string的结构体的初始容量立16个字节；而capcity测算的字符串的长度没有算\0所有capcity为15个字节；

2.2string类的常用接口说明

①默认成员函数

2.2.1.string类对象的常见构造（成员函数）

构造函数和拷贝构造函数

2.2.1.1构造函数使用方法：

2.2.2.string类对象的析构函数

自动调用；不用写；

2.2.3.重载赋值（string::operator=)

例子：

②迭代器

迭代器一共4个：

非const迭代器

上面讲了非const的正反迭代器；
下面我将讲诉const的正反迭代器；

const的迭代器

当对象的begin是const类型时；
就要使用const迭代器；
正序：

倒序：

注意：迭代器可以用于所有数据结构的遍历；

string类对象的访问及遍历操作（迭代器）

、

方法1:使用[]来遍历字符串；

方法2：迭代器begin和end

迭代器的使用：
类模板+::+iterator+名字；
这里的迭代器可以想想为指针；
方法3：迭代器 rbegin和rend（反向遍历）

这里2和3的类型名过长；可以使用auto类型
auto可以直接i将等号后面的类型拷贝到等号前的类型中；

方法4：使用范围for（c++的for循环的简写）

for (auto ch : s1)//这里的s1是数据结构
	{
		cout << ch << "";
	}
	cout << endl;
1
2
3
4
5

范围for会将s1的所有数据依次传递给ch；直到运输完；
这里范围for的本质就是迭代器：原理范围for将编译器改为迭代器来使用；本质与第2个相同；这里的不支持倒着遍历；

③容量

size（）和length（）

size_t size() const;
1

**作用：**字符串的大小；
string先创造出来；stl后创造出来；
string先创作了length（）来计算字符串的长度；stl创造了size（）来计算数据结构的大小；string就将length用size替代；

这里字符串的/0是为了兼容c语言；

capacity（）

size_t capacity() const;
1

作用：调用返回字符串的容量；

clear（）

调用clear函数会将内存的数据清理；但是不收回内存；

empty

清空内存；

reserve（）和resize

reserve（）

作用：为string预留空间，不改变有效元素个数，

注意区别reserve和reverse（别写错了）
reserve——保留
reverse——反转

当reserve的参数小于string的底层空间总大小时，reserve不会改变容量大小；

resize（）

void resize（size_t n)
void resize (size_t n,char c)
相同点：
两者都是将字符串中的有效字符改变到n个，
不同：
当字符个数增加时；resize（n)用/0来填充多出的元素；resize（size_t n,char c)用字符c来填充多出的元素空间。
n大小不同的情况

④元素访问

operator【】

 char& operator[] (size_t pos);
 const char& operator[] (size_t pos) const;
1
2

获取字符串的字符；
返回对字符串中位置的字符的引用。
例子

// string::operator[]
#include 
#include 

int main ()
{
  std::string str ("Test string");
  for (int i=0; i<str.length(); ++i)
  {
    std::cout << str[i];
  }
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

at

char& at (size_t pos);
const char& at (size_t pos) const;
1
2

与【】的作用相同都是获取字符串的字符；
返回对i字符串中位置的引用；

【】和at的区别：

【】越界直接断言；
at 越界抛异常；

⑤元素的插入

尾插

append（）

push_back()

由于append和push_back的函数种类过于繁琐；使用较少；所以使用时请自行查找；

operator+=（重点）

string (1)	
string& operator+= (const string& str);
c-string (2)	
string& operator+= (const char* s);
character (3)	
string& operator+= (char c);
1
2
3
4
5
6

+=不能再初始化的时侯使用；

operator+（全局函数）（+=是成员函数）

string (1)	
string operator+ (const string& lhs, const string& rhs);
c-string (2)	
string operator+ (const string& lhs, const char*   rhs);string operator+ (const char*   lhs, const string& rhs);
character (3)	
string operator+ (const string& lhs, char          rhs);string operator+ (char          lhs, const string& rhs);
1
2
3
4
5
6

例子：

+相比+=返回值是值传递需要多次拷贝构造函数；复杂度较高；
所以建议减少使用+；
+函数的原理

赋值

assign((覆盖赋值）

string (1)	
string& assign (const string& str);
substring (2)	
string& assign (const string& str, size_t subpos, size_t sublen);
c-string (3)	
string& assign (const char* s);
buffer (4)	
string& assign (const char* s, size_t n);
fill (5)	
string& assign (size_t n, char c);
range (6)	
template <class InputIterator>   string& assign (InputIterator first, InputIterator last);

1
2
3
4
5
6
7
8
9
10
11
12
13

例子：

具体用时自己查；

头插（insert）

string& insert (size_t pos, const string& str);
substring (2)	
 string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
c-string (3)	
 string& insert (size_t pos, const char* s);
buffer (4)	
 string& insert (size_t pos, const char* s, size_t n);
fill (5)	
 string& insert (size_t pos, size_t n, char c);   
  void insert (iterator p, size_t n, char c);
single character (6)	
iterator insert (iterator p, char c);
range (7)	
template <class InputIterator>   void insert (iterator p, InputIterator first, InputIterator last);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

由上面的函数声明；可以判断头插；只有两种类型；6和5都可以是实现；
示例

头插经量减少使用；因为要挪动数据；

删除（erase）

sequence (1)	
//删除
 string& erase (size_t pos = 0, size_t len = npos);

1
2
3
4

这里的pos是删除的前指针；len是删除的尾指针；
这里的指针默认字符串的末尾；
例子

替换（replace）

string (1)	
string& replace (size_t pos,  size_t len,  const string& str);string& replace (iterator i1, iterator i2, const string& str);
substring (2)	
string& replace (size_t pos,  size_t len,  const string& str,                 size_t subpos, size_t sublen);
c-string (3)	
string& replace (size_t pos,  size_t len,  const char* s);string& replace (iterator i1, iterator i2, const char* s);
buffer (4)	
string& replace (size_t pos,  size_t len,  const char* s, size_t n);string& replace (iterator i1, iterator i2, const char* s, size_t n);
fill (5)	
string& replace (size_t pos,  size_t len,  size_t n, char c);string& replace (iterator i1, iterator i2, size_t n, char c);
range (6)	
template <class InputIterator>  string& replace (iterator i1, iterator i2,                   InputIterator first, InputIterator last);

1
2
3
4
5
6
7
8
9
10
11
12
13
14

举例：
单个替换

string& replace (size_t pos,  size_t len,  const string& str);
1

pos是起始位置；
len是替换的长度；
str是替换的字符串；

这里的空间变大；设计挪动数据；

insert和erase的使用建议；

尽量不要使用；原因：都涉及数据的移动；复杂度较高；
接口设计复杂繁多，需要时擦一下文档即可；
多个替换
1.可使用其他数组类替换掉

2.只允许在本数组中进行替换

这里有三种方法:
1和2是赋值法：这里的复杂度还可以（只调用一次拷贝构造函数）
3.由于交换（全局函数）需要创建变量并进行三次拷贝构造函数；
补：swap成员函数；

⑥ 字符串操作

c_str

将字符串改为C语言版本

data

const char* data() const;
1

返回值是c语言的字符串的首地址；
例子：

// string::data
#include 
#include 
#include 

int main ()
{
  int length;

  std::string str = "Test string";
  char* cstr = "Test string";

  if ( str.length() == std::strlen(cstr) )
  {
    std::cout << "str and cstr have the same length.\n";

    if ( memcmp (cstr, str.data(), str.length() ) == 0 )
      std::cout << "str and cstr have the same content.\n";
  }
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

find系列

1.find（正序查找）

string (1)	
size_t find (const string& str, size_t pos = 0) const;
c-string (2)	
size_t find (const char* s, size_t pos = 0) const;
buffer (3)	
size_t find (const char* s, size_t pos, size_t n) const;
character (4)	
size_t find (char c, size_t pos = 0) const;
1
2
3
4
5
6
7
8

Find content in string（这里找到是出现的第一个位置）

这由于pos有缺失参数；所以不用写初始位置；

2.rfind

string (1)	
size_t rfind (const string& str, size_t pos = npos) const;
c-string (2)	
size_t rfind (const char* s, size_t pos = npos) const;
buffer (3)	
size_t rfind (const char* s, size_t pos, size_t n) const;
character (4)	
size_t rfind (char c, size_t pos = npos) const;
1
2
3
4
5
6
7
8

Find last occurrence of content in string (public member function)（这里找到是出现的最后位置）

这里的默认参数是末尾位置；

substr

string substr (size_t pos = 0, size_t len = npos) const;
1

这里是将字符串的一部分输出；
pos是起始位置；npos输出的个数；
补充
算个数的方法:j将数据i想象为左闭右开的数据；数据个数：左数据下标-右数据下标；

三个函数的应用：

3. find_first_of

string (1)	
size_t find_first_of (const string& str, size_t pos = 0) const;
c-string (2)	
size_t find_first_of (const char* s, size_t pos = 0) const;
buffer (3)	
size_t find_first_of (const char* s, size_t pos, size_t n) const;
character (4)	
size_t find_first_of (char c, size_t pos = 0) const;

1
2
3
4
5
6
7
8
9

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

这个函数的作用在str（从前往后）中找s中的元素（s不按顺序）只要和”s“中的一样就算找到，

4.find_last_of

string (1)	
size_t find_last_of (const string& str, size_t pos = npos) const;
c-string (2)	
size_t find_last_of (const char* s, size_t pos = npos) const;
buffer (3)	
size_t find_last_of (const char* s, size_t pos, size_t n) const;
character (4)	
size_t find_last_of (char c, size_t pos = npos) const;
1
2
3
4
5
6
7
8

这个函数的作用在str（从后往前）中找s中的元素（s不按顺序）只要和”s“中的一样就算找到，

5.find_first_not_of

string (1)	
size_t find_first_not_of (const string& str, size_t pos = 0) const;
c-string (2)	
size_t find_first_not_of (const char* s, size_t pos = 0) const;
buffer (3)	
size_t find_first_not_of (const char* s, size_t pos, size_t n) const;
character (4)	
size_t find_first_not_of (char c, size_t pos = 0) const;
1
2
3
4
5
6
7
8

这个函数的作用在str（从前往后）中找s中的不存在的元素（s不按顺序）只要和”s“中的一样就算找到。

6.find_last_not_of

string (1)	
size_t find_last_not_of (const string& str, size_t pos = npos) const;
c-string (2)	
size_t find_last_not_of (const char* s, size_t pos = npos) const;
buffer (3)	
size_t find_last_not_of (const char* s, size_t pos, size_t n) const;
character (4)	
size_t find_last_not_of (char c, size_t pos = npos) const;

1
2
3
4
5
6
7
8
9

这个函数的作用在str（从前往后）中找s中的不存在的元素（s不按顺序）只要和”s“中的一样就算找到。