Aillieo Collection

SUBTITLE

0%

std::string Cheatsheet

发表于 更新于 分类于

std::string的相关函数，使用时应包含<string>。

basic_string：

1
template <class CharType, class Traits = char_traits<CharType>, class Allocator = allocator<CharType>> class basic_string;

string：

1
typedef basic_string<char, char_traits<char>, allocator<char>> string;

成员函数

构造函数

构造函数共有9种重载形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
string(); 
//空构造函数，得到一个长度为0的字符串。

string(const string& str); 
//拷贝构造函数，使用一个已有字符串构造新的字符串。

string(const string& str, size_t pos, size_t len = npos); 
//"size_t"是无符号整型；从另一个字符串str中截取从pos开始的长度为len的字符串，如果len超过字符串结尾或未指定，则截取到结尾。

string(const char* s); 
//使用C风格字符串构造

string(const char* s, size_t n); 
//从s所指向的字符数组中赋值前n个字符构造字符串

string(size_t n, char c); 
//使用连续的n个字符c来构造字符串

template <class InputIterator>
string(InputIterator first, InputIterator last); 
//用[first,last)中的字符序列来构造字符串

string(initializer_list<char> il);  // c++ 11
//使用初始化列表中的字符来构造

string(string&& str) noexcept;  // c++ 11
//使用右值引用来构造

析构函数

1
~string();

operator=

赋新的值并取代当前内容，赋值函数共有5种重载形式，其中最后2种是C++11的内容：

1
2
3
4
5
6
7
8
9
10
11
string& operator= (const string& str);	

string& operator= (const char* s);	

string& operator= (char c);	

string& operator= (initializer_list<char> il);	// c++ 11
//初始化列值表赋值

string& operator= (string&& str) noexcept;	  // c++ 11
//右值引用 move

迭代器

begin

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

返回对应容器起点位置的迭代器

end

1
2
iterator end();
const_iterator end() const;

返回对应超尾元素位置的迭代器，即最后一个字符后边的位置。

rbegin

1
2
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

返回指向容器最后一个位置的反向迭代器，可通过自增操作到达字符串起点位置。

rend

1
2
3
4
5
6
reverse_iterator rend();
const_reverse_iterator rend() const;
const_iterator cbegin() const noexcept; //c++ 11
const_iterator cend() const noexcept; //c++ 11
const_reverse_iterator crbegin() const noexcept; //c++ 11
const_reverse_iterator crend() const noexcept; //c++ 11

返回指向反向超尾元素的反向迭代器，即指向字符串第一个字符前边的位置。

字符串长度

size

1
size_t size() const;

返回字符串的长度，以byte为单位。返回的是字符串内容对应的byte数，但不一定等同于存储容量。
当计算字符串长度时，不会考虑其包含的字符的解码方式。因此如果使用的是多字节或变长度编码方式的字符，返回值可能并不是实际字符的个数。

string::size和string::length是相同的，会返回一样的值。

length

1
size_t length() const;

返回字符串长度。

max_size

1
size_t max_size() const;

返回字符串可以达到的最大长度。
此最大值是由系统或库的实现所限制的，但是在实际使用中可能会受到其他限制而达不到此最大值。

resize

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

将字符串的长度改变为n个字符的长度。如果n小于当前长度，则删掉多余的部分；如果n大于当前长度，则补到n，如果指定了字符c则补全的部分为字符c，否则用空字符（null）补全。

capacity

1
size_t capacity() const;

返回分配的存储空间，以字节为单位。此处的容量capacity不一定等于字符串长度，可能会等于或大于。当为了优化此对象的增加新字符等操作而留有额外的空间时会大于字符串长度。

此容量不代表字符串的最大长度，当分配的空间用尽且需要更多时则会自动重新分配。字符串理论上最大长度用其成员max_size表示。

在对字符串对象进行修改时会改变其容量。显式调用reserve可以改变字符串的容量。

reserve

1
void reserve (size_t n = 0);

将字符串的容量改为n。如果n大于当前字符串的容量，则会使容器增大容量到n或大于n。除了这种情况之外，则会缩小字符串的容量。这是一个non-binding操作，但容器的实现会进行一些优化操作，所以容量会大于n。此函数不会影响字符串的长度也不会改变其内容。

clear

1
void clear();

删除字符所有内容，变成一个空字符串。

empty

1
bool empty() const;

检查字符串是否为空。

shrink_to_fit

1
void shrink_to_fit();

使字符串减小容量以匹配其尺寸。这是一个non-binding操作。容器的实现会进行一些优化操作，所以容量会大于n。此函数不会影响字符串的长度也不会改变其内容。

字符访问

operator[]

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

返回字符串中位于pos位置的字符的引用。

at

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

返回字符串中位于pos位置的字符的引用。如果pos超出字符串长度，则会抛出out_of_range异常。

back

1
2
char& back(); //c++11
const char& back() const; //c++11

返回最后一个字符的引用，不能对空字符串调用此函数。

front

1
2
char& front(); //c++ 11
const char& front() const; //c++ 11

返回第一个字符的引用，不能对空字符串调用此函数。

字符串修改

operator+=

1
2
3
4
string& operator+= (const string& str);
string& operator+= (const char* s);
string& operator+= (char c);
string& operator+= (initializer_list<char> il); //c++11

在尾部增加一个或多个字符以延长字符串。

append

1
2
3
4
5
6
7
8
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);
string& append (initializer_list<char> il); // c++11

在尾部增加一个或多个字符以延长字符串。

push_back

1
void push_back (char c);

在字符串尾部增加字符c，并使长度增加1。

assign

1
2
3
4
5
6
7
8
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);
string& assign (initializer_list<char> il);  //c++11

给字符串赋予新内容，并取代原有的内容。

insert

1
2
3
4
5
6
7
8
9
10
11
12
string& insert (size_t pos, const string& str);
string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
// 插入字符串str的子字符串。

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);
string& insert (const_iterator p, initializer_list<char> il); //c++11

在pos或p的位置之前插入新的字符或字符串。

erase

1
2
3
4
5
6
string& erase (size_t pos = 0, size_t len = npos);
// 删除从pos起的长度为len的字符串

iterator erase (iterator p);
iterator erase (iterator first, iterator last);
// 删除p位置的字符或从first到last的一段字符串，返回完成删除后位于p或first的迭代器

删除字符串中的字符或删除字符串的某一部分，缩减长度。

replace

1
2
3
4
5
6
7
8
9
10
11
12
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);
string& replace (const_iterator i1, const_iterator i2, initializer_list<char> il); //c++11

替换字符串中pos起长度为len或位于i1和i2之间（含i1不含i2）的一部分。

swap

1
void swap (string& str);

交换字符串的值，两个字符串的长度可以不一样。调用此函数后，调用该函数的字符串对象的内容将变成字符串str原有的内容，而str的内容会变成调用函数的字符串之前的内容。

有一个非成员函数swap()，可以实现相同的功能，并且实现算法更优。

pop_back

1
void pop_back(); //c++11

删除字符串最后一个字符，并且长度减1。

字符串操作

c_str

1
const char* c_str() const;

返回其内部的存储字符串内容的字符数组，即C风格的字符串。使用string::data和 string::c_str 会得到相同的值。

data

1
const char* data() const;

同string::c_str ，返回其内部的存储字符串内容的字符数组。返回的字符串会以一个\0结尾。

get_allocator

1
allocator_type get_allocator() const;

获取该字符串的分配器。字符串string使用的是默认allocator<char>分配器。

copy

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

将字符串中从pos起长度为len的一部分存入s指向的数组。该方法不会在复制的字符尾部加\0。返回值为复制的字符数。

find

1
2
3
4
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;

查找字符串内容。查找字符串中首次出现参数（str、s或c）的地方。如果指定了pos则查找范围限定为为pos之后（含pos）的位置。与find_first_of不同，当查找的对象为多个字符时，必须匹配整段字符才认为查找到。

返回值为查找到的首次出现的位置，如果查找不到则返回string::npos。

rfind

1
2
3
4
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;

查找对应参数（str、s或c）在字符串中最后一次出现的位置。如果指定了pos则查找范围限制为pos之前（含pos）的内容。

find_first_of

1
2
3
4
5
6
7
8
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;

在字符串中查找字符首次出现的位置。如果指定了pos则查找范围限定为为pos之后（含pos）的位置。注意只要满足首个字符匹配（并不要求匹配整个字符串）则认为查找到。

find_last_of

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

在字符串中查找字符最后一次出现的位置。如果指定了pos则查找范围限定为为pos之前（含pos）的位置。

find_first_not_of

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

查找字符串，查找目标为首个与指定参数不一致的字符。

find_last_not_of

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

从后向前查找首次出现的与指定参数不一致的字符。

substr

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

取字符串中pos起长度为len的内容成为子字符串并返回，未指定len时取至原字符串末尾。

compare

1
2
3
4
5
6
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;

比较该字符串或其子字符串与其参数指定的字符串，原字符串与参数指定的比较字符串完全一致时会返回0。以下情况会返回负值：

  1. 出现的首个不同字符，原字符串中大于参数指定的比较字符串

  2. 比较的字符串完全一致，并且原字符串长度长于参数指定的字符串

反之会返回正数结果。

成员常量

npos

1
static const size_t npos = -1;

表示size_t的最大值（size_t表示非负整数，因此定义为-1表示其最大可能的值），当用于长度时（上文中的len），表示直到字符串的末尾。当用于表示查询结果时，npos表示未找到匹配。

非成员重载函数

operator+

1
2
3
4
5
6
7
8
9
10
11
12
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);
string operator+ (string&&      lhs, string&&      rhs); //c++11
string operator+ (string&&      lhs, const string& rhs); //c++11
string operator+ (const string& lhs, string&&      rhs); //c++11
string operator+ (string&&      lhs, const char*   rhs); //c++11
string operator+ (const char*   lhs, string&&      rhs); //c++11
string operator+ (string&&      lhs, char          rhs); //c++11
string operator+ (char          lhs, string&&      rhs); //c++11

返回新构造的字符串，字符串的内容为lhs和rhs拼接。在C++11中，如果两个参数应至少有一个右值引用，则返回的对象由该参数move构造，之后右值引用的参数会处于不定状态，如果两个参数都是右值引用，则会有一个参数被move，另一个参数保留原值。

relational operators

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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);

比较字符串对象lhs 和rhs的大小关系。实际调用的是string::compare方法。这些比较符号在<string>中重载。

swap

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

交换两个字符串的内容，作用类似于调用x.swap(y)。

operator>>

1
istream& operator>> (istream& is, string& str);

从输入流中提取字符串到str，并覆盖str中原有内容。提取的过程中会把空格当做分隔符，因此此操作只能用来从流中提取单词（a word）。如需提取整行文本，可参考getline。

operator<<

1
ostream& operator<< (ostream& os, const string& str);

向流os中输出构成字符串str的字符。

getline

1
2
3
4
istream& getline (istream& is, string& str, char delim);
istream& getline (istream& is, string& str);
istream& getline (istream&& is, string& str, char delim); //c++11
istream& getline (istream&& is, string& str); //c++11

从流中获取内容存储到字符串str，直到遇到delim为止。遇到delim时会将其提取但并不存入str。对于未定义delim的情况使用\n作为分隔符。当遇到文件结尾或其他错误时也会停止获取。

有用的操作

之前在项目中用到的三个函数，记录在此：

格式化构造字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using std::string;
const int MaxStringLen = 1024*100;
string format (const char * format, ...)
{
    char* pBuf = (char*)malloc(MaxStringLen);
    if(pBuf == nullptr)
    {
        return "";
    }
    else
    {
        va_list arglist;
        va_start(arglist, format);
        vsnprintf(pBuf, MaxStringLen, format, arglist);
        va_end(arglist);
        string tmp = string(pBuf);
        free(pBuf);
        return tmp;
    }
}

字符串分裂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
using std::string;
using std::vector;
vector<string> splitString( const string& str , const std::string& sep )
{
	vector<string> strs;
	if (str.empty())
	{
		return strs;
	}
  
	string tmp;
	string::size_type pos_begin = str.find_first_not_of(sep);
	string::size_type comma_pos = 0;

	while (pos_begin != string::npos)
	{
		comma_pos = str.find(sep, pos_begin);
		if (comma_pos != string::npos)
		{
			tmp = str.substr(pos_begin, comma_pos - pos_begin);
			pos_begin = comma_pos + sep.length();
		}
		else
		{
			tmp = str.substr(pos_begin);
			pos_begin = comma_pos;
		}

		if (!tmp.empty())
		{
			strs.push_back(tmp);
			tmp.clear();
		}
	}
	return strs;
}

字符串修剪

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
using std::string;
string trim(const string& str, bool trimLeft=true, bool trimRight=true)
{
	if(!trimLeft && !trimRight){
		return str;
	}

	string tmp = str;
	string::iterator it;

	if(trimLeft)
	{
		for (it = tmp.begin(); it != tmp.end(); it++) 
        {
			if (!isspace(*it)) 
            {
				tmp.erase(tmp.begin(), it);
				break;
			}
		}

		if (it == tmp.end()) 
        {
			return tmp;
		}
	}

	if (trimRight)
	{
		for (it = tmp.end() - 1; it != tmp.begin(); it--) 
        {
			if (!isspace(*it)) 
            {
				tmp.erase(it + 1, tmp.end());
				break;
			}
		}
	}

	return tmp;
}

REFERENCE

http://www.cplusplus.com/reference/string/string/

http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html

https://msdn.microsoft.com/en-us/library/syxtdd4f.aspx