【C++】STL-string类深入学习

说明：本博客所有代码结果均源自vs2019 32位下运行

1.初识string类

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>
   string;
4. 不能操作多字节或者变长字符的序列。

2.string类对象的常见构造

1）string()

默认构造函数，得到一个空的string对象

2）string (const string& str)

拷贝构造，用已经存在的字符串来创建新的string对象

3）string (const string& str, size_t pos, size_t len = npos)

使用字符串str的从pos下标开始，长度为len这一部分字符串来构造新的string对象（len是一个缺省参数，默认值为npos,如果不给定，默认到字符串str的末尾）

4）string (const char* s)

用字符串来构造新的string对象

5）string (const char* s, size_t n)

用字符串s的前n个字符来构造新的string对象

6）string (size_t n, char c)

使用n个字符c构建新的string对象

7）template

string (InputIterator first, InputIterator last);使用迭代器用给定字符串的区间来构建新的string对象

迭代器后文会讲

3.string类对象的容量操作

1）size

size_t size() const;

获取字符串有效长度

2）length

size_t length() const;

获取字符串有效长度（与size功能一样）

3）max_size

size_t max_size() const;

字符串所能达到的最大长度

这是在VS2019下运行的结果，不同编译器可能不同

4）resize

void resize (size_t n);
void resize (size_t n, char c);

将string中有效字符的个数调整到newsize个

1. newsize<=oldsize
   
2. newsize>oldsize&&newsize<=capacity
   
   
3. newsize>oldsize&&newsize>capacity
   
   
   区别在于前一个的后续元素以\0填充，后一个则由字符a填充
   

5）capacity

size_t capacity() const;

获取string对象在底层维护的顺序表的容量

6）reserve

void reserve (size_t n = 0);

改变string对象容量（只改变容量，不会改变有效元素个数 ）

在vs2019下，string是按照1.5倍的方式扩容，在linux下是按照2倍的方式扩容

7）clear

void clear();

清空有效元素个数，但不会改变容量大小

4.string类对象的访问

1）operator[]

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

用于获取string对象pos处的字符

如果越界访问，会触发assert断言，终止程序

2）at

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

用法和operator[]相同都是获取pos处的字符，区别在于operator[]会触发断言终止程序，但是at在访问越界时会抛出异常，便于用户捕捉

3）back（c++11）

 char& back();
const char& back() const;

用于获取string对象的最后一个字符，也可以用来修改最后一个字符

4）front（c++11）

      char& front();
const char& front() const;

用于获取string对象的第一个字符，也可以用来修该第一个字符

5.string中迭代器及元素的遍历

string中的迭代器类似于指针，但并非真正的指针

1）begin&&end

begin为string对象的第一个元素处，end为string对象最后一个元素即\0处

iterator begin();
const_iterator begin() const;

iterator end();
const_iterator end() const;

2）rbegin&&rend

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

reverse_iterator rend();
const_reverse_iterator rend() const;

begin为string对象的第一个元素的前一个元素处，end为string对象最后一个元素即\0的前一个处

3）范围for遍历

int main()
{
	
	string s1("hello world!");
	

	for (auto e : s1)
	{
		cout << e;
	}

	return 0;
}

4）迭代器遍历

int main()
{
	string s1("hello world!");

	string::iterator p = s1.begin();
	while (p != s1.end())
	{
		cout << *p;
		p++;
	}

	return 0;
}

5）for循环+[]遍历

int main()
{
	string s1("hello world!");
	for (int i = 0; i < s1.size(); i++)
	{
		cout << s1[i];
	}

	return 0;
}

6.string类对象的修改操作

1）operator+=

string& operator+= (const string& str);//末尾追加string对象
string& operator+= (const char* s);//末尾追加s字符串
string& operator+= (char c);//末尾追加c字符

2）append

string& append (const string& str);//末尾追加str
	
string& append (const string& str, size_t subpos, size_t sublen);末尾追加从str的subpos开始，长度为sublen的子串

string& append (const char* s)；//末尾追加一个s字符串

string& append (const char* s, size_t n);//末尾追加一个s字符串从0号下标开始长度为n的子串

string& append (size_t n, char c);//末尾追加n个字符c

template <class InputIterator>
   string& append (InputIterator first, InputIterator last);//追加迭代器first到last区间的内容

3）assign

用法与append类似，append是从末尾开始插入，assign从0号位置开始插入（即每次插入都会清空原有内容）

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);

4）push_back

void push_back (char c);

末尾增加一个字符c

5）insert

 string& insert (size_t pos, const string& str);//在pos处插入string对象str

 string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);//在pos处插入string对象str从subpos开始长为sublen的子串

 string& insert (size_t pos, const char* s);//在pos处插入字符串s

 string& insert (size_t pos, const char* s, size_t n);//在pos处插入字符串s的前n个字符

 string& insert (size_t pos, size_t n, char c);
    void insert (iterator p, size_t n, char c);//在pos处插入n个字符c

iterator insert (iterator p, char c);//在p处插入字符c

template <class InputIterator>
   void insert (iterator p, InputIterator first, InputIterator last)；//利用迭代器在p处插入first到last的子串

6）erase

 string& erase (size_t pos = 0, size_t len = npos);//从pos出开始，删除长度为len的子串，pos和npos均为缺省参数，默认删掉整个字符串

 iterator erase (iterator p);//删除p位置元素，返回下一个元素位置

 iterator erase (iterator first, iterator last);删除区间fairst到last间元素

7）swap

交换两个string对象内容

void swap (string& str);

7.string类非成员函数

1）find

size_t find (const string& str, size_t pos = 0) const;//在目标字符串中查找str字符串出现的位置，默认从头开始查找。找到返回str首个字符在目标字符串中的位置，找不到返回npos
	
size_t find (const char* s, size_t pos = 0) const;//功能与上一个一致，查询字符串s出现的位置

size_t find (const char* s, size_t pos, size_t n) const;//查询字符串s的前n个字符
	
size_t find (char c, size_t pos = 0) const;//查询字符c

2）rfind

功能与find类似，但是是从string对象末尾开始找

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;

3）substr

截取子串,pos为截取的起始位置，len表示截取的长度

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