链接: string

C语言中的字符串

C语言中，字符串是以’\0’结尾的一些字符的集合，为了方便操作，C标准库里面提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太复合OOP（OOP即面向对象程序设计，全称为Object Oriented Programming）的思想，而且底层空间需要用户自己管理，可能还会又越界访问。

标准库中的string类

1.字符串是表示字符序列的类
2.标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性
3.string类是使用char（即作为它的字符类型，使用它的char_traits和分配器类型）
4.string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数
5.注意这个类独立于所使用的编码来处理字节：如果用来处理多字节或变长字符的序列，这个类的所有成员（如长度或者大小）已经它的迭代器，将仍然按照字节（而不是实际编码的字符）来操作

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

【注意】在使用string类时，必须包含#include头文件以及using namespace std;

string类

• string 类

1.strings是代表一系列字符的对象。
2.这个标准字符串类提供支持这样的对象有类似于标准字节容器的接口，但是增加了尤其是专门设计去处理单字节字符的字符串的功能
3.这个字符串类是一个标准字符串类的模板的实例，使用类似的字符类型char
4.注意此类是独立于之前的编码去处理字节：如果去处理多字节或者可变长度字符，则此类的所有成员及其迭代器仍然以字节为单位进行操作。

成员变量

string类的常用接口说明

成员函数

string(constructor构造函数)

• string构造函数
• 初始化字符串对象，初始化的值取决于使用的构造函数的版本。

（1）无参构造函数（默认构造函数）

default (1)
string();

构造一个空的字符串，长度为0的字符

	string s1;

（2）拷贝构造函数

copy (2)
string (const string& str);

构造一个字符串的拷贝

	string s2("hello world!");
	string s3(s2);

（3）substring构造函数

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

拷贝部分字符串，在pos位置的字符开始，len字符数的间隔

	string s4("Hello world!", 6, 5);//wor
	string s5(s3, 0, 1);//w

（4）拷贝字符串的构造函数

from c-string (4)
string (const char* s);

拷贝指向c-字符串，以null为终止的字符串。

	string s6("Hello!");

（5）拷贝部分字符串的构造函数

from sequence (5)
string (const char* s, size_t n);

在指向c-字符串的字符串数组中拷贝前n个字符。

	string s7("Hello!", 2);//He

（6）填充字符的构造函数

fill (6)
string (size_t n, char c);

用字符c的n个连续的字符填充字符串。

	string s8("x", 8);//xxxxxxxx

~string(destructor析构函数)

• 字符串析构函数
• 销毁字符串对象

字符串析构函数解除分配字符串分配的所有存储空间。

int main()
{
	string s1("hello world!");
	s1.~string();
	return 0;
}

存在默认析构函数，所有可以不写。

默认赋值运算符重载函数

• string::operator=
• 字符串的分配
• 给字符串分配一个新的值，取代当前的内容。

（1）string

string& operator= (const string& str);

赋值一个自定义字符串类型

	string s1("Hello world!");
	string s2;
	s2 = s1;

（2）c-string

string& operator= (const char* s);

赋值一个字符串数组

	string s3;
	s3 = "hello";

（3）character

string& operator= (char c);

赋值一个字符

	string s4;
	s4 = 'h';

遍历string

下面介绍三种遍历string字符串的方式。

下标+[ ]

• string::operator[]
• 获取字符串元素
• 返回一个在pos位置处的元素

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

（1）和（2）分别使用在自定义函数是否存在const限制，防止权限的放大。

遍历string并访问

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

遍历string并修改

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

迭代器

在现阶段，迭代器的使用可以类似于指针，后续在使用迭代器时，又可能是指针，也又可能不是指针。

在C++98中，string类中介绍了4种函数。

• string::begin
• 将迭代器返回至开始
• 返回迭代器指向的第一个元素的值

（1）iterator begin();
（2）const_iterator begin() const;

• 防止权限的放大

• string::end
• 将迭代器返回至结束
• 将迭代器指向最后一个元素的下一个位置的值，即’\0’的值。
• the past end是一个理论字符，它将跟随字符串的最后一个字符，它不应该被取消引用。
• 由于被标准库的函数所使用的范围不包括迭代器所指定的元素，这个函数经常被使用在与string::begin结合，去指定包括字符串所有元素的范围。
• 如果对象是一个空字符串，则返回string::begin相同的值

遍历string并打印

	string s1("Hello world!");
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << endl;
		++it;
	}

遍历string并修改

	string s1("Hello world!");
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		(*it)++;
		it++;
	}

范围for

访问字符串并打印

	string s("hello world!");
	for (char ch : s)
	{
		cout << ch << " ";
	}

访问字符串并修改

	string s("hello world!");
	for (char& ch : s)
	{
		++ch;
	}

【注意】在修改字符串时，需要使用引用，是因为范围for在读取s字符串时，是将s的值赋值给ch。

• 范围for的底层代替为迭代器，下面在汇编角度观察

• 一个类只要支持迭代器，就会支持范围for的用法
• 任何容器都支持迭代器，并且用法是类似。

【总结】iterator提供了一种统一的方式访问和修改容器的数据，迭代器可以和算法很好地配合，算法可以通过迭代器，去处理容器中的数据。

反向迭代器

反向迭代器和迭代器刚好相反

• rbegin
  
  （1）reverse_iterator rbegin();
  （2）const_reverse_iterator rbegin() const;

• 返回反向迭代器至反向开始
• 返回一个反向迭代器的一个点指向字符串的最后一个元素

• rend
  
  （1） reverse_iterator rend();
  （2）const_reverse_iterator rend() const;

• 返回反向迭代器至反向结束
• 返回一个反向迭代器的一个点指向字符串的第一个元素

使用迭代器同时可以进行字符串的遍历

	string s("hello world!");
	string::reverse_iterator it = s.rbegin();
	//auto it = s.rbgein();
	while (it != s.rend())
	{
		cout << *it << " ";
		++it;
	}

【注意】权限放大与缩小的问题，如果需要迭代的字符串是被const修饰的时候，需要使用的是const修饰的函数，否则会存在权限放大的故障。

capacity

size

• 返回字符串的长度
• size_t size() const;

(1)返回字符串的长度，以字节为单位。
(2)实际字节的数量遵守字符串内容，不一定存储容量相等。
(3)注意字符串在不知道编码的情况下处理字节，可能最终被用于编码包含的字符串。因此，返回值在多字节或者不同长度的元素顺序中可能与实际编码元素的值不同。
(4)string::size 与 string::length 是同义词，返回值相同。

	string s("Hello world!");
	cout << s.size() << endl;

length

• 返回字符串的长度
• size_t length() const;

内容与string::size基本相似

	string s("hello world!");
	cout << s.length() << endl;

max_size

• 返回字符串的最大长度
• size_t max_size() const;

(1)返回字符串可以读取到的最大长度
(2)字符串可以读取到的最大的可能长度，是由于已知系统或者库实现限制决定。但是这个对象不保证可以达到这样的长度：它仍然可能无法分配存储在长度无法到达的点上。

	string s1;
	cout << s1.max_size() << endl;
	string s2("hello world!");
	cout << s2.max_size() << endl;

resize

• void resize (size_t n);
• void resize (size_t n, char c);
• 调整字符串

(1)将字符串的大小调整为n个字符的长度
(2)当n比当前字符串的长度小，当前值缩短至前n个字符，删除n个字符以外的字符
(3)当n比当前字符串的长度长，通过插入当前内容最后被扩展至n大小的所需要的字符。如果指定c，新元素会被初始化为c的副本，否则它们是值初始化的字符。

	//当n比字符串长度小时
	string s1("hello world!");
	s1.resize(5);
	cout << s1 << endl;
	//当n比字符串长度长时
	string s2("hello world!");
	s2.resize(15);
	cout << s2 << endl;

	//当n比字符串长度小时
	string s1("hello world!");
	s1.resize(5,'x');
	cout << s1 << endl;
	//当n比字符串长度长时
	string s2("hello world!");
	s2.resize(20,'x');
	cout << s2 << endl;

capacity

• size_t capacity() const;
• 返回被分配的存储的大小

(1)返回字符串当前分配的存储空间的大小，用字节表示
(2)这个容量不同于字符串的长度。可以与之相等或者更长，当新的元素增加至字符串中时，额外的空间允许对象进行优化操作。
(3)注意，这个容量不假设字符串的长度有限制。当空间被用尽或者需要更多时，对象会自然地扩展。字符串地理论限制是由成员函数max_size决定。
(4)字符串的容量会在任何时候对象修改的时候修改，即使这种修改意味着尺寸的缩小或者容量尚未耗尽。
(5)字符串的容量可以被成员函数reverse明确修改

	string s("hello world!");
	cout << s.capacity() << endl;

【注意】不同的编译器的底层实现不同，即容量可能会出现不同。

reserve

• void reserve (size_t n = 0);
• 请求更改容量

(1)请求字符串容量适应一个在长度最多n个字符的计划中的改变
(2)如果n大于当前字符串容量，这个函数造成容器将容量增加至n个字符
(3)在其他所有的实例中，它被视为收缩字符串容量的收缩性请求：容器的实现是自由优化的，此外保留字符串的容量大于n
(4)这个函数对字符串的长度没有影响，并且无法改变其内容。

	string s("hello world!");
	cout << s.capacity() << endl;
	s.reserve(20);
	cout << s.capacity() << endl;

clear

• void clear();
• 清除字符串

(1)清除字符串的容量，将其变成空字符串。

	string s("hello world!");
	s.clear();
	//遍历打印
	for (int i = 0; i < s.size(); ++i)
	{
		cout << s[i] << endl;
	}

empty

• bool empty() const;
• 判断字符串是否为空

(1)返回字符串是否为空
(2)这个函数没有使用任何方式修改字符串的值。

	string s("hello world!");
	cout << s.empty() << endl;
	s.clear();
	cout << s.empty() << endl;

【注意】
1.size()与length()方法实现底层原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是使用size()
2.clear()只是将string中的有效字符清空，不改变底层空间大小
3.resize(size_t n)与resize(size_t n,char c)都是将字符串中有效字符个数改变为n个，不同的是，当字符个数增多时，resize(size_t n)会用0来填充多出的元素空间；而resize(size_t n, char c)会用字符c来填充多出的元素空间。
4.resize在改变元素个数时，如果元素个数增多，可能会改变底层容量的大小，如果将元素个数减小，底层空间总大小不会改变。
5.当reserve();如果里面有数据，不会收缩；如果被clear();清理后，可能会收缩。
6.reserve();只会将capacity();改变，而resize();不仅会将改变空间，同时会填充值并初始化。

Element access（元素访问）

operator[ ]

• 获取字符串的元素。
• char& operator[] (size_t pos);
• const char& operator[] (size_t pos) const;
• 返回一个在pos位置处的元素

at

• char& at (size_t pos);
• const char& at (size_t pos) const;
• 在字符串中获取元素
• 返回一个字符串中pos位置的参考元素。
• 这个函数会自动检查在字符冲中pos位置是否为元素的有效位置（如果越界会抛异常）

	string s1("hello world");
	s1.at(1) = 'x';
	cout << s1 << endl;

【注意】使用operator[]与at()基本相同，但是需要注意的是如果operator[]越界访问会被断言，ar()会出现抛异常。

Modifiers（字符串进行修改）

operator+=

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

+=一个字符串

	string s1("hello");
	s1 += "world";
	cout << s1 << endl;

• c-string (2)
  string& operator+= (const char* s);

+=一个只读字符

	string s1("hello");
	s1 += 'x';
	cout << s1 << endl;

• character (3)
  string& operator+= (char c);

+=一个元素

	string s1("hello");
	char c = 'm';
	s1 += c;
	cout << s1 << endl;

• 字符串附加
• 在当前值的末尾通过其他字符扩展字符串

append

• string (1)
  string& append (const string& str);

string：附加一个str的副本

	string s1("hello");
	s1.append("world");
	cout << s1 << endl;

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

substring：附加一个str的子字符串的副本。这个子字符串是str的一部分，在元素位置subpos开始，间隔sublen个元素个数。

	string s1("hello");
	s1.append("world", 2, 3);
	cout << s1 << endl;

• c-string (3)
  string& append (const char* s);

c-string：附加一个由s指向以null结尾字符串序列形成的字符串的副本。

	string s1("hello");
	s1.append("world");
	cout << s1 << endl;

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

buffer：附加一个由s指向元素位置的前n个元素的副本。

	string s1("hello");
	s1.append("world", 3);
	cout << s1 << endl;

• fill (5)
  string& append (size_t n, char c);

fill：附加那个连续的字符c的副本

	string s1("hello");
	s1.append(5,'x');
	cout << s1 << endl;

• range (6)
  template < class InputIterator>
  string& append (InputIterator first, InputIterator last);

initializer list（初始值设定项列表）：按照相同的顺序附加 il 中每一个字符的副本。

push_back

• void push_back (char c);
• 附加元素到附加元素c到字符串末尾，将其长度加一

	string s1("hello");
	s1.push_back('x');
	cout << s1 << endl;

assign

【注意】分配一个新内容到字符串，取代当前内容

• string (1)
  string& assign (const string& str);

string：拷贝字符串

	string s1("hello");
	s1.assign("world");
	cout << s1 << endl;

• substring (2)
  string& assign (const string& str, size_t subpos, size_t sublen);

substring：拷贝str的一部分，在subpos元素位置开始，间隔sublen个元素

	string s1("hello world");
	s1.assign("world", 3, 2);
	cout << s1 << endl;

• c-string (3)
  string& assign (const char* s);

c-string：拷贝s指向的以null结束的元素列表

	string s1("hello");
	s1.assign("world");
	cout << s1 << endl;

• buffer (4)
  string& assign (const char* s, size_t n);

buffer：拷贝s指向的元素数组的前n个元素

	string s1("hello");
	s1.assign("world", 2);
	cout << s1 << endl;

• fill (5)
  string& assign (size_t n, char c);

fill：被n个连续的字符c的拷贝代替当前的值

	string s1("hello world");
	s1.assign(5, 'x');
	cout << s1 << endl;

• range (6)
  template < class InputIterator>
  string& assign (InputIterator first, InputIterator last);

range：使用相同的顺序在范围内拷贝元素顺序。

insert

std::string::insert
【注意】在pos指示的位置之前插入附加的元素到字符串中。

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

string：插入str的拷贝

	string s1("hello");
	s1.insert(5, "world");
	cout << s1 << endl;

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

substring：插入str的子字符串的拷贝，这个子字符串是str的一部风，在subpos元素位置开始，间隔sublen个元素

	string s1("hello");
	s1.insert(1, "world", 3, 2);
	cout << s1 << endl;

• c-string (3)
  string& insert (size_t pos, const char* s);

c-string：插入由s指向以null结束的字符列表形成的字符串的一个拷贝

	string s1("hello");
	s1.insert(5, "world");
	cout << s1 << endl;

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

buffer：插入由s指向数组中的元素的前n个元素的拷贝

	string s1("hello");
	s1.insert(2, "world", 3);
	cout << s1 << endl;

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

fill：插入n个连续的字符c的拷贝

	string s1("hello");
	s1.insert(2, 3,'x');
	cout << s1 << endl;

• single character (6)
  iterator insert (iterator p, char c);

single character：插入字符c

	string s1("hello");
	s1.insert(s1.begin() + 1, 'x');
	cout << s1 << endl;

• range (7)
  template < class InputIterator>
  void insert (iterator p, InputIterator first, InputIterator last);

range：使用相同的顺序在范围内拷贝元素顺序

【注意】size_t是无符号整数类型

erase

• std::string::erase

• 擦除字符串中的元素

• 擦除部分字符串，缩减其长度

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

sequence：擦除字符串的部分值，这个值开始于pos位置，间隔len长度

	string s1("hello");
	s1.erase(2, 2);
	cout << s1 << endl;

• character (2)
  iterator erase (iterator p);

character：擦除指向p的元素

	string s1("hello");
	s1.erase(s1.begin() + 1);
	cout << s1 << endl;

replace

• std::string::replace
• 取代部分字符串
• 取代部分字符串，开始于pos位置，间隔len个元素

swap

• std::string::swap
• void swap (string& str);
• 交换字符串的值

String operations（字符串进行操作）

c_str

• std::string::c_str
• const char* c_str() const;
• 获取等效的c字符串
• 返回一个指针指向一个包含null结束的字符序列的数组，代表当前字符串的值。
• 此数组包含相同的字符序列，将string对象的值加上末尾的附加终止null字符（‘\0’）组成
• 程序不得更改序列中的任何字符
• 返回的指针可能会因进一步调用修改对象的其他成员函数而失效

【注意】c_str();是为了让c的一些接口函数配合

	string s1("hello");
	cout << s1.c_str() << endl;

copy

• std::string::copy
• size_t copy (char* s, size_t len, size_t pos = 0) const;
• 从字符串中拷贝字符序列

find

• std::string::find
• 在字符串中查找内容

	string ur1 = "https://editor.csdn.net/md?articleId=139749504";
	size_t pos1 = ur1.find("://");
	string protocal;//协议
	if (pos1 != string::npos)
	{
		protocal = ur1.substr(0, pos1);
	}
	string domain;//域名
	string resource;//资源名
	size_t pos2 = ur1.find('/', pos1 + 3);
	if (pos2 != string::npos)
	{
		domain = ur1.substr(pos1 + 3, pos2 - (pos1 + 3));
		resource = ur1.substr(pos2 + 1);//
	}
	cout << protocal << endl;
	cout << domain << endl;
	cout <<resource << endl;

rfind

• std::string::rfind
• 寻找在字符串最后发生的内容
• 寻找由其参数指定的序列的字符串最后发生的内容

find_first_of

• std::string::find_first_of
• 查找字符串中的元素
• 寻找字符串中的第一个元素，匹配其参数中指定的任何字符

	string s1("Searches the string for the first character that matches any of the characters specified in its arguments.");
	size_t found = s1.find_first_of("abc");
	while (found != string::npos)
	{
		s1[found] = '*';
		found = s1.find_first_of("abc", found + 1);
	}
	cout << s1 << endl;

find_last_of

• std::string::find_last_of
• 从后面开始在字符串中寻找字符

find_first_not_of

• std::string::find_first_not_of
• 在字符串中查找缺席的字符

find_last_not_of

• std::string::find_last_not_of
• 从后面开始查找在字符串中不匹配的字符

substr

• std::string::substr
• 生成子字符串

compare

• std::string::compare
• 比较俩个字符串

【注意】
1.在str尾部追加字符时，s.push_back©/s.append(1,c)/s += 'x’三种实现方式基本差不多，一般情况下string类的+=操作使用较多，+=不仅可以连接单个字符，同时也可以连接字符串。
2.对string进行操作时，如果能够预估到多少字符，可以使用reserve把空间预留好。

Member constants（成员常量）

npos

• std::string::npos
• size_t的最大值

Non-member function overloads（非成员函数重载）

operator+ (string)

• std::operator+ (string)
• 连接字符串

relational operators (string)

• relational operators (string)
• 字符串的关系运算符

swap (string)

• std::swap (string)
• 交换俩个字符串的值

operator>> (string)

• std::operator>> (string)
• 从流中提取字符串

operator<< (string)

• std::operator<< (string)
• 将字符串插入流中

getline (string)

• std::getline (string)
• 获取流中的全部字符串