【C++序列式容器】string

秋秋晗晗

已于 2024-02-14 15:13:58 修改

阅读量849

点赞数 3

分类专栏： C++容器文章标签： c++

于 2023-03-04 14:59:21 首次发布

本文链接：https://blog.csdn.net/Qiuhan_909/article/details/129112881

版权

C++容器专栏收录该内容

12 篇文章 3 订阅

订阅专栏

一个容器就是一些特定类型对象的集合。序列式容器（sequence container）为程序员提供了控制元素存储和访问顺序的能力。这种顺序不依赖于元素的值，而是与元素加入容器时的位置相对应。

序列式容器	名称	访问	插入/删除
string	字符串	支持快速随机访问	在尾部插入/删除速度快
array	固定大小数组	支持快速随机访问	不能插入/删除元素
vector	可变大小数组	支持快速随机访问	在尾部插入/删除速度快
forward_list	单向链表	只支持单向顺序访问	在任何位置插入/删除速度都很快
list	双向链表	只支持双向顺序访问	在任何位置插入/删除速度都很快
deque	双端队列	支持快速随机访问	在头尾位置插入/删除速度快

除了固定大小的array外，其他容器都提供高效、灵活的内存管理。我们可以添加和删除元素，扩张和收缩容器的大小。容器保存元素的策略对容器操作的效率有着固有的，有时是重大的影响。在某些情况下，存储策略还会影响特定容器是否支持特定操作。

例如，string和vector将元素保存在连续的内存空间中。由于元素是连续存储的，由元素的下标来计算其地址是非常快速的。但是，在这两种容器的中间位置添加或删除元素就会非常耗时：在一次插入或删除操作后，需要移动插入/删除位置之后的所有元素，来保持连续存储。而且，添加一个元素有时可能还需要分配额外的存储空间。在这种情况下，每个元素都必须移动到新的存储空间中。

list和forward_list两个容器的设计目的是令容器任何位置的添加和删除操作都很快速。作为代价，这两个容器不支持元素的随机访问：为了访问一个元素，我们只能遍历整个容器。而且，与vector、deque和array相比，这两个容器的额外内存开销也很大。

deque是一个更为复杂的数据结构。与string和vector类似，deque支持快速的随机访问。与string和vector一样，在deque的中间位置添加或删除元素的代价（可能）很高。但是，在deque的两端添加或删除元素都是很快的，与list或forward_list添加删除元素的速度相当。

forward_list和array是新C++标准增加的类型。与内置数组相比，array是一种更安全、更容易使用的数组类型。与内置数组类似，array对象的大小是固定的。因此，array不支持添加和删除元素以及改变容器大小的操作。forward_list的设计目标是达到与最好的手写的单向链表数据结构相当的性能。因此，forward_list没有size操作，因为保存或计算其大小就会比手写链表多出额外的开销。对其他容器而言，size保证是一个快速的常量时间的操作。

以下是一些选择容器的基本原则：

除非你有很好的理由选择其他容器，否则应使用vector。
如果你的程序有很多小的元素，且空间的额外开销很重要，则不要使用list或forward_list。
如果程序要求随机访问元素，应使用vector或deque。
如果程序要求在容器的中间插入或删除元素，应使用list或forward_list。如果程序需要在头尾位置插入或删除元素，但不会在中间位置进行插入或删除操作，则使用deque。
如果程序只有在读取输入时才需要在容器中间位置插入元素，随后需要随机访问元素，则
1. 首先，确定是否真的需要在容器中间位置添加元素。当处理输入数据时，通常可以很容易地向vector追加数据，然后再调用标准库的sort函数来重排容器中的元素，从而避免在中间位置添加元素。
2. 如果必须在中间位置插入元素，考虑在输入阶段使用list，一旦输入完成，将list中的内容拷贝到一个vector中。

string

1. Member functions

1.1 constructor、destructor、operator=

1.1.1 constructor

1.1.2 destructor

1.1.3 operator=

1.2 Iterators

1.3 Capacity

1.4 Element access

1.5 Modifiers

1.6 String operations

1.6.9 find_first_not_of

1.6.10 find_last_not_of

1.6.11 substr

1.6.12 compare

2. Member constants

2.1 npos

3. Non-member function overloads

3.1 operator+

3.2 relational operators

string

typedef basic_string<char> string;

字符串是代表字符序列的对象。

标准的string类为这类对象提供了支持，其接口与标准的字节容器类似，但增加了专门为操作单字节字符的字符串而设计的功能。

string类是basic_string类模板的实例，它使用char（即字节）作为其字符类型，并具有默认的char_traits和allocator类型（关于模板的更多信息请参见basic_string）。

请注意，该类处理字节的方式与使用的编码无关：如果用于处理多字节或可变长度的字符序列（如UTF-8），这个类的所有成员（如length或size），以及它的迭代器，仍将以字节为单位进行操作（而不是实际编码的字符）。

string定义在头文件string和命名空间std中。

1. Member functions

1.1 constructor、destructor、operator=

1.1.1 constructor

// default (1) 默认构造
string();
// copy (2) 拷贝构造
string(const string& str);
// substring (3) 用str中从pos开始的len个字符的子串来构造，如果str太短或len为string::npos，则直到str的末尾
string(const string& str, size_t pos, size_t len = npos);
// from c-string (4) 用C格式字符串来构造
string(const char* s);
// from buffer (5) 用s指向的字符串中前n个字符来构造
string(const char* s, size_t n);
// fill (6) 用n个字符c来构造
string(size_t n, char c);
// range (7) 用迭代器区间[first,last)中的字符序列来构造
template <class InputIterator> string(InputIterator first, InputIterator last);
// initializer list (8) 用初始化列表来构造
string(initializer_list<char> il);
// move (9) 移动构造
string(string&& str) noexcept;

#include <string>
#include <iostream>
using namespace std;

int main()
{
	string s1;          // default
	cout << s1 << endl; // 空字符串

	string s2("hello world"); // from c-string
	cout << s2 << endl;       // hello world

	string s3(s2);      // copy
	// 等价于string s3 = s2;
	cout << s3 << endl; // hello world

	string s4(s3, 0, 5); // substring
	cout << s4 << endl;  // hello

	string s5("hello world", 5); // from buffer
	cout << s5 << endl;          // hello

	string s6(10, '*'); // fill
	cout << s6 << endl; // **********

	string s7(s2.begin() + 6, s2.end()); // range
	cout << s7 << endl;                  // world

	string s8{ 'h','a','p','p','y' }; // initializer list
	// 等价于string s8 = { 'h','a','p','p','y' };
	cout << s8 << endl;               // happy

	string s9(std::move(s8));     // move
	cout << "s8: " << s8 << endl; // s8: 
	cout << "s9: " << s9 << endl; // s9: happy

	return 0;
}

1.1.2 destructor

~string();

1.1.3 operator=

// string (1)
string& operator=(const string& str);
// c-string (2)
string& operator=(const char* s);
// character (3)
string& operator=(char c);
// initializer list (4)
string& operator=(initializer_list<char> il);
// move (5)
string& operator=(string&& str) noexcept;

#include <string>
#include <iostream>
using namespace std;

int main()
{
	string s("hello world");
	cout << s << endl; // hello world

	string s1;
	s1 = s;             // string
	cout << s1 << endl; // hello world

	string s2;
	s2 = "hello";       // c-string
	cout << s2 << endl; // hello

	string s3;
	s3 = 'f';           // character
	cout << s3 << endl; // f

	string s4;
	s4 = { 'h','a','p','p','y' }; // initializer list
	cout << s4 << endl;           // happy

	string s5;
	s5 = std::move(s4);           // move
	cout << "s4: " << s4 << endl; // s4:
	cout << "s5: " << s5 << endl; // s5: happy

	return 0;
}

1.2 Iterators

// begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
// end
iterator end() noexcept;
const_iterator end() const noexcept;
// rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
// rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
// cbegin
const_iterator cbegin() const noexcept;
// cend
const_iterator cend() const noexcept;
// crbegin
const_reverse_iterator crbegin() const noexcept;
// crend
const_reverse_iterator crend() const noexcept;

函数	功能
begin & end	begin返回一个迭代器，指向字符串的第一个字符 end返回一个迭代器，指向字符串的最后一个字符的下一个位置
rbegin & rend	rbegin返回一个反向迭代器，指向字符串的最后一个字符 rend返回一个反向迭代器，指向字符串的第一个字符的上一个位置
cbegin & cend	cbegin返回一个const迭代器，指向字符串的第一个字符 cend返回一个const迭代器，指向字符串的最后一个字符的下一个位置
crbegin & crend	crbegin返回一个const反向迭代器，指向字符串的最后一个字符 crend返回一个const反向迭代器，指向字符串的第一个字符的上一个位置

函数

功能

begin

end

begin返回一个迭代器，指向字符串的第一个字符

end返回一个迭代器，指向字符串的最后一个字符的下一个位置

rbegin

rend

rbegin返回一个反向迭代器，指向字符串的最后一个字符

rend返回一个反向迭代器，指向字符串的第一个字符的上一个位置

cbegin

cend

cbegin返回一个const迭代器，指向字符串的第一个字符

cend返回一个const迭代器，指向字符串的最后一个字符的下一个位置

crbegin

crend

crbegin返回一个const反向迭代器，指向字符串的最后一个字符

crend返回一个const反向迭代器，指向字符串的第一个字符的上一个位置

begin&end和rbegin&rend返回的迭代器指向：

const_iterator是一个指向const内容的迭代器。迭代器本身可以修改，但是它不能被用来修改它所指向的内容。

begin&end/rbegin&rend和cbegin&cend/crbegin&crend的不同：

begin&end/rbegin&rend的返回类型由对象是否是常量来决定。如果不是常量，返回iterator；如果是常量，返回const_iterator。
cbegin&cend/crbegin&crend的返回类型是const_iterator，不管对象本身是否是常量。

#include <string>
#include <iostream>
using namespace std;

int main()
{
	string s("hello world");

	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	// h e l l o   w o r l d

	auto rit = s.rbegin();
	// string::reverse_iterator rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
	// d l r o w   o l l e h

	return 0;
}

1.3 Capacity