1. 默认成员函数

构造函数

//默认构造
string();
//拷贝构造
string (const string& str);
//指定拷贝字符串,pos是起始位置,npos是长度
string (const string& str, size_t pos, size_t len = npos);
//构造一个*s字符串
string (const char* s);
//n是构造*s字符串的位数
string (const char* s, size_t n);
//用c初始化字符串,n是字符个数,如n=3,c='x',字符串就是"xxx"
string (size_t n, char c);
//用迭代器传参
template <class InputIterator>
  string  (InputIterator first, InputIterator last);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

s1虽然是默认构造,构造的是"",其实后面都有一个\0的

operator=

string& operator= (const string& str);
	
string& operator= (const char* s);

string& operator= (char c);
1
2
3
4
5

string& operator= (char c);vs2022环境下无法编译,可能是认为太鸡肋了吧

2.迭代器(iterator)

迭代器是一个像指针一样的类型,底层可能是指针,也可能不是指针,用法和指针类似

begin/end(重点)

rbegin/rend (反向迭代器)(重点)

注意:返回值是reverse_iterator

cbegin/cend

这个使用begin和end也没关系,因为会赋值会自动缩小权限

crbegin/crend

这个使用rbegin和rend也没关系,因为会赋值会自动缩小权限

string迭代器的本质

string,vector迭代器的本质就是指针,因为他们的地址空间是连续的
而list,map,set… 地址空间是不连续的,是打乱的,所以本质不是指针,具体等说到这些容器再讲!

3. 容量有关操作(Capacity)

size/length(重点)

就是计算字符串长度的!
这两个本质是一样的,但是更推荐size,因为其他的容器中都是用的这个,尤其是树型结构!!

max_size(不常用)

返回字符串可以达到的最大长度。

resize

将字符串大小调整为n 个字符的长度。 如果n小于当前字符串长度，则将当前值缩短为其第一个n字符，删除第n个之后的字符。 如果n大于当前字符串长度，则通过在末尾插入所需数量的字符来扩展当前内容，以达到n的大小。如果指定c，则新元素将初始化为c的副本，否则，它们是值初始化字符（空字符）。

简单来说就是重新设置一下字符串大小(和string中的size比),设置小了就删,多了就补,不指定补什么就补’0’

capacity(容量)

用来获取字符串的容量的,大于等于size

reserve

简单说就是更改容量的,你输入的参数小于本来的容量就视为非法,容器实现可以自由优化，否则字符串容量大于n,大于本来的容量就修改修改容量,实现扩容

我们发现编译器多扩了一点,这是因为每个编译器的扩容机制不一样,但是他肯定能保证大于你设置的

clear

擦除string的内容，变为空字符串（长度为0个字符）。

empty(重要)

返回字符串是否为空（即其长度是否为0）

shrink_to_fit(C++11特性,不重要)

请求字符串减小其容量以适应其大小。
该请求是非绑定的，容器实现可以自由优化，否则字符串的容量大于其size。
此函数对字符串长度没有影响，并且不能更改其内容。

4. 元素访问 (Element access)

operator[]

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

返回对字符串中位置pos的字符的引用(如果非法直接中断)
让string可以像数组那样操作

at

返回对字符串中位置pos的字符的引用。 该函数自动检查pos是否是字符串中字符的有效位置（即pos是否小于字符串 length），如果不是则抛出out_of_range异常。
和operator[]类似,只不过他是抛异常,而operator[]是直接中断.

front/back

返回第一个字符的引用或者最后一个字符引用

5.修饰符

operator+=/append

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

string& operator+= (const char* s);

string& operator+= (char c);

string& append (const string& str);

string& append (const string& str, size_t subpos, size_t sublen);

string& append (const char* s);

string& append (const char* s, size_t n);

string& append (size_t n, char c);

template <class InputIterator>
   string& append (InputIterator first, InputIterator last);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

都是通过在其当前值的末尾附加附加字符来 扩展字符串

push_back

将字符c 附加到string的末尾，将其长度增加一。

assign(全替换)(不常用)

为字符串分配一个新值，替换其当前内容。

string& assign (const string& str);
	
string& assign (const string& str, size_t subpos, size_t sublen);
	
string& assign (const char* s);
	
string& assign (const char* s, size_t n);
	
string& assign (size_t n, char c);

template <class InputIterator>
   string& assign (InputIterator first, InputIterator last);
1
2
3
4
5
6
7
8
9
10
11
12

我认为这东西,还不低使用=来的爽!

insert(插入)

在pos（或p ）指示的字符之前将 其他字符插入到字符串中：

string& insert (size_t pos, const string& str);

 string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);

 string& insert (size_t pos, const char* s);

 string& insert (size_t pos, const char* s, size_t n);

 string& insert (size_t pos, size_t n, char c);
    void insert (iterator p, size_t n, char c);

iterator insert (iterator p, char c);

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
15

效率较低,因为这是移动字符串插入的

erase(删除)

string& erase (size_t pos = 0, size_t len = npos);

iterator erase (iterator p);

iterator erase (iterator first, iterator last);
1
2
3
4
5

replace(部分替换)

用新内容替换从字符pos开始并跨越len个字符的字符串部分（或[i1,i2)范围内的字符串部分）：

string& replace (size_t pos,  size_t len,  const string& str);
string& replace (iterator i1, iterator i2, const string& str);

string& replace (size_t pos,  size_t len,  const string& str,
                 size_t subpos, size_t sublen);
	
string& replace (size_t pos,  size_t len,  const char* s);
string& replace (iterator i1, iterator i2, const char* s);

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);
	
string& replace (size_t pos,  size_t len,  size_t n, char c);
string& replace (iterator i1, iterator i2, size_t n, char c);
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
15
16
17

swap

通过str 的内容交换容器的内容，这是另一个字符串对象。长度可能不同。
调用这个成员函数后，这个对象的值就是调用前str的值，str的值就是调用前这个对象的值。
请注意，存在一个同名的非成员函数swap，并使用与此成员函数类似的优化来重载该算法。

pop_back

删除最后一个字符

6.字符串操作

c_str/data

返回一个指向数组的指针，该数组包含一个以空字符结尾的字符序列（即一个 C 字符串），表示字符串对象的当前值。
此数组包含构成字符串对象值的相同字符序列，以及末尾的附加终止空字符 ( ‘\0’ )。

简单理解就是把这个字符串的首元素地址拿出来
推荐使用c_str

copy

size_t copy (char* s, size_t len, size_t pos = 0) const;
1

将字符串对象 的当前值的子字符串复制到s指向的数组中。此子字符串包含从位置pos开始的len 个字符。 该函数不会在复制内容的末尾附加空字符。

find/rfind

size_t find (const string& str, size_t pos = 0) const;
	
size_t find (const char* s, size_t pos = 0) const;
	
size_t find (const char* s, size_t pos, size_t n) const;
	
size_t find (char c, size_t pos = 0) const;
	
size_t rfind (const string& str, size_t pos = npos) const;
	
size_t rfind (const char* s, size_t pos = npos) const;
	
size_t rfind (const char* s, size_t pos, size_t n) const;
	
size_t rfind (char c, size_t pos = npos) const;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在字符串中 搜索由其参数指定的序列的第一次/最后一次出现。
当指定pos时，搜索仅包括位置pos或之后的字符，忽略任何可能出现的包括pos之前的字符。

find_front_of/find_last_of

在字符串中 搜索与其参数中指定的任何字符匹配的第一个字符/最后一个字符。
当指定pos时，搜索仅包括位置pos或之后的字符，忽略pos之前任何可能出现的字符。

find_front_not_of/find_last_not_of

在字符串中 搜索与其参数中指定的任何字符都不匹配的第一个字符/最后一个字符。
当指定pos时，搜索仅包括位置pos或之后的字符，忽略该字符之前的任何可能出现。

substr

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

返回一个字符串

通常和find配合使用,比如分割url

compare

int compare (const string& str) const;
	
int compare (size_t pos, size_t len, const string& str) const;

int compare (size_t pos, size_t len, const string& str,
             size_t subpos, size_t sublen) const;
	
int compare (const char* s) const;

int compare (size_t pos, size_t len, const char* s) const;
	
int compare (size_t pos, size_t len, const char* s, size_t n) const;
1
2
3
4
5
6
7
8
9
10
11
12

字符串按字典序比较,大于返回正数,小于返回负数,等于返回0

7.非成员函数重载

operator+

string operator+ (const string& lhs, const string& rhs);

string operator+ (const string& lhs, const char*   rhs);
string operator+ (const char*   lhs, const string& rhs);

string operator+ (const string& lhs, char  rhs);
string operator+ (char lhs, const string& rhs);
1
2
3
4
5
6
7

拼接字符串返回一个新的string对象

relational operators(关系运算符)

bool operator== (const string& lhs, const string& rhs);
bool operator== (const char* lhs, const string& rhs);
bool operator== (const string& lhs, const char* rhs);

bool operator!= (const string& lhs, const string& rhs);
bool operator!= (const char* lhs, const string& rhs);
bool operator!= (const string& lhs, const char* rhs);

bool operator< (const string& lhs, const string& rhs);
bool operator< (const char* lhs, const string& rhs);
bool operator< (const string& lhs, const char* rhs);

bool operator<= (const string& lhs, const string& rhs);
bool operator<= (const char* lhs, const string& rhs);
bool operator<= (const string& lhs, const char* rhs);

bool operator> (const string& lhs, const string& rhs);
bool operator> (const char* lhs, const string& rhs);
bool operator> (const string& lhs, const char* rhs);

bool operator>= (const string& lhs, const string& rhs);
bool operator>= (const char* lhs, const string& rhs);
bool operator>= (const string& lhs, const char* rhs);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

按字典序判断其大小

swap

void swap (string& x, string& y);
1

交换字符串内容,和x.swap(y)一样

operator>>/operator<<

通俗易懂的话就是重载写入和读取

getline

istream& getline (istream& is, string& str, char delim);

istream& getline (istream& is, string& str);
1
2
3

有一种情景就是我们想要输入"I am boy!"到一个字符串中,我们平时输入多个对象就是使用空白符(空格,\n,tab…)来分割的,使用我们使用cin输入,不能完全输入进去,使用使用getline!