string类及其成员函数总结

1、string的构造函数的形式

string str1;                 //生成空字符串
string str2("123456789");    //生成"1234456789"的复制品
string str3("12345", 0, 3);  //结果为"123"
string str4("012345", 5);    //结果为"01234"
string str5(5, '1');         //结果为"11111"
string str6(str2, 2);        //结果为"3456789"

string str：生成空字符串
string s(str)：生成字符串为str的复制品
string s(str, str_begin, str_len)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值
string s(cstr, char_len)：以C_string类型cstr的前char_len个字符串作为字符串s的初值
string s(num, char)：生成num个c字符的字符串
string s(str, str_index)：将字符串str中从下标str_index开始到字符串结束的位置作为字符串初值

2、string的大小和容量

string str("1234567");
cout << "size=" << s.size() << endl;         // size=7
cout << "length=" << s.length() << endl;     // length=7
cout << "max_size=" << s.max_size() << endl; // max_size=4294967294
cout << "capacity=" << s.capacity() << endl; // capacity=15
s.resize(12);	cout << "size=" << s.size() << endl;	// size=12
s.reserve(19);	cout << "capacity=" << s.capacity() << endl; // capacity=31
int a=s.empty();	//如果字符串长度为 0，则返回 true，否则返回 false
s.shrink_to_fit(); 
s.clear();

（1）、size()和length()：返回string对象的字符个数，他们执行效果相同。
（2）、max_size()：返回string对象最多包含的字符数，超出会抛出length_error异常
（3）、capacity()：重新分配内存之前，string对象能包含的最大字符数
（4）、resize()：调整字符串size的大小
（5）、reserve()：改变容量capacity大小
（6）、empty()：测试字符串是否为空，如果字符串长度为 0，则返回 true，否则返回 false
（7）、shrink_to_fit()：用于收缩以适应
（8）、clear()：清除字符串

3、string的字符串比较

string A("aBcdf");
string B("AbcdF");
string C("123456");
string D("123dfg");

cout << "A.compare(B)：" << A.compare(B) << endl;	//"aBcdf"和"AbcdF"比较，a>A，返回1
cout << "A.compare(2, 2, B)：" << A.compare(2, 2, B)<< endl;	//"cd"和“AbcdF"比较，c>A，返回1
cout << "A.compare(2, 2, B, 2, 2)：" << A.compare(2, 2, B, 2, 2) << endl;	//"cd"和“cd"比较，返回0
cout << "C.compare(0, 4, D, 0, 4)：" << C.compare(0, 4, D, 0, 4)<< endl;	//1234"和"123d"比较，返回-1

（1）比较操作符: >, >=, <, <=, ==, !=
这些操作符根据“当前字符特性”将字符按字典顺序进行逐一比较，字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小(前面减后面)
（2）成员函数compare()
支持多参数处理，支持用索引值和长度定位子串进行比较，前面减去后面的ASCII码，>0返回1，<0返回-1，相同返回0

str1.compare(str2): compare str1[0, _Mysize) with _Right
str1.compare(_Off, _N0, str2): compare str1[_Off, _Off + _N0) with str2
str1.compare(_Off,_N0,str2,_Roff,_Count): compare str1[_Off,_Off+_N0) with str2[_Roff,_Roff+_Count)
str1.compare(*_Ptr): compare str1[0, _Mysize) with [_Ptr, <null>)
str1.compare(_Off, _N0, *_Ptr, _Count): compare str1[_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)

4、string的插入：push_back() 和 insert()

    // 尾插一个字符
    s1.push_back('a');
    s1.push_back('b');
    s1.push_back('c');
    cout<<"s1:"<<s1<<endl; // s1:abc

    // insert(pos,char):在制定的位置pos前插入字符char
    s1.insert(s1.begin(),'1');
    cout<<"s1:"<<s1<<endl; // s1:1abc

5、string拼接字符串：append() 、 +

//方法一：append()
string s1("abc");
s1.append("def");
cout<<"s1:"<<s1<<endl; // s1:abcdef

// 方法二：+ 操作符
string s2 = "abc";
/*s2 += "def";*/
string s3 = "def";
s2 += s3.c_str();
cout<<"s2:"<<s2<<endl; // s2:abcdef

6、string的遍历：借助迭代器或者下标法

string s1("abcdef");

// 正向迭代器
string::iterator iter = s1.begin();
for( ; iter < s1.end() ; iter++)
{
    cout<<*iter;
}
cout<<endl;   //abcdef

// 反向迭代器
string::reverse_iterator riter = s1.rbegin();
for( ; riter < s1.rend() ; riter++)
{
    cout<<*riter;
}
cout<<endl;  //fedcba

（1）正向迭代器 str.begin()、str.end()
（2）反向迭代器 str.rbegin()、str.rend()
（3）const正向迭代器 str.cbegin()、str.cend()
（4）const反向迭代器 str.crbegin()、str.crend()

7、string的删除：erase()

string s1 = "123456789";

s1.erase(s1.begin() + 1);                 // 结果：13456789
s1.erase(s1.begin() + 1, s1.end() - 2);   // 结果：189
s1.erase(1,6);                            // 结果：189

iterator erase(iterator p)：删除字符串中p所指的字符
iterator erase(iterator first, iterator last)：删除字符串中迭代器区间 [first, last) 上所有字符
string& erase(size_t pos, size_t len)：删除字符串中从索引位置 pos 开始的 len 个字符
void clear()：删除字符串中所有字符

8、string的字符替换

string s1("hello,world!");

s1.replace(6, 5, "girl");                       // 结果：hello,girl.
s1.replace(s1.size() - 1, 1, 1, '.');           // 结果：hello,world.
s1.replace(s1.begin(), s1.begin() + 5, "boy");  // 结果：boy,girl.

string& replace(size_t pos, size_t n, const char *s)：将当前字符串从pos索引开始的n个字符，替换成字符串s
string& replace(size_t pos, size_t n, size_t n1, char c)：将当前字符串从pos索引开始的n个字符，替换成n1个字符c
string& replace(iterator i1, iterator i2, const char* s)：将当前字符串[i1,i2)区间中的字符串替换为字符串s

9、string大小写转换：tolower() 和 toupper() 或者 STL中的transform算法

string s = "ABCDEFG";

for( int i = 0; i < s.size(); i++ )
{
    s[i] = tolower(s[i]);
} 
cout << s << endl;  //abcdefg

transform(s.begin(), s.end(), s.begin(), ::toupper); 
cout << s << endl;  //"ABCDEFG"

tolower(char) 和 toupper(char) ：将字符进行大小写转换
transform(_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)：transform [_First, _Last) with _Func

10、string的查找：find

string s("dog bird chicken bird cat");

//字符串查找-----找到后返回首字母在字符串中的下标
// 1. 查找一个字符串
cout << s.find("chicken") << endl;        // 结果是：9
// 2. 从下标为6开始找字符'i'，返回找到的第一个i的下标
cout << s.find('i', 6) << endl;            // 结果是：11
// 3. 从字符串的末尾开始查找字符串，返回的还是首字母在字符串中的下标
cout << s.rfind("chicken") << endl;       // 结果是：9
// 4. 从字符串的末尾开始查找字符
cout << s.rfind('i') << endl;             // 结果是：18
// 5. 在该字符串中查找第一个属于字符串s的字符
cout << s.find_first_of("13br98") << endl;  // 结果是：4("b")
// 6. 在该字符串中查找第一个不属于字符串s的字符，先匹配dog，然后bird匹配不到，所以打印4
cout << s.find_first_not_of("hello dog 2006") << endl; // 结果是：4
// 7. 在该字符串从后往前查找第一个属于字符串s的字符
cout << s.find_last_of("13r98") << endl;               // 结果是：19
// 8. 在该字符串从后往前查找第一个不属于字符串s的字符，先匹配tac，然后空格匹配不到，所以打印21
cout << s.find_last_not_of("teac") << endl;            // 结果是：21

（1）find (const char* s, size_t pos)：在当前字符串的pos索引位置开始，查找子串s，返回找到的位置索引
（2）find (char c, size_t pos)：在当前字符串的pos索引位置开始，查找字符c，返回找到的位置索引
（3）rfind (const char* s, size_t pos)：在当前字符串的pos索引位置开始，反向查找子串s，返回找到的位置索引
（4）rfind (char c, size_t pos)：在当前字符串的pos索引位置开始，反向查找字符c，返回找到的位置索引
（5）find_first_of (const char* s, size_t pos)：在当前字符串的pos索引位置开始，查找子串s的字符，返回找到的位置索引
（6）find_first_not_of (const char* s, size_t pos)：在当前字符串的pos索引位置开始，查找第一个不位于子串s的字符，返回找到的位置索引
（7）find_last_of(const char* s, size_t pos)：在当前字符串的pos索引位置开始，向前查找第一个位于子串s的字符，返回找到的位置索引
（8）find_last_not_of (const char* s, size_t pos)：在当前字符串的pos索引位置开始，向前查找第一个不位于子串s的字符，返回找到的位置索引

11、string的排序

string s = "cdbaef";
sort(s.begin(), s.begin() + 3);
cout << "s：" << s << endl;    //s：bcdaef

sort(iterator iter1, iterator iter2)：对[iter1, iter2)进行排序

12、string的分割/截取字符串：substr()

返回一个新构造的字符串对象，其值初始化为该对象的子字符串的副本

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

str − 它是一个字符串对象
len − 它用于复制字符。
pos − 要复制的第一个字符的位置

string s1("0123456789");
string s2 = s1.substr(2, 5); 
cout << s2 << endl;    // 结果：23456，参数5表示截取的字符串的长度

string str("I,am,a,student; hello world!");
string split(",; !");

int iCurrentIndex = 0;
int iSplitIndex;
while (iCurrentIndex < str.size()) {
    iSplitIndex = str.find_first_of(split, iCurrentIndex);
    if (iSplitIndex == -1)
        iSplitIndex = str.size();

    if (iSplitIndex != iCurrentIndex)
        cout << str.substr(iCurrentIndex, iSplitIndex - iCurrentIndex) << endl;
        
     iCurrentIndex = iSplitIndex + 1;
}
/**********************************
结果：
    I
    am
    a
    student
    hello
    world
*/

13、string转换为char *

标准库的string类提供了3个成员函数来从一个string得到c类型的字符数组：c_str()、data()、copy(p,n)

1、 c_str()：生成一个const char*指针，指向以空字符终止的数组；

char* c=new char[20];
string s="1234";
strcpy(c,s.c_str());
cout<<c<<endl; //输出：1234

c_str()函数返回一个指向正规C字符串的指针常量, 内容与本string串相同。这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。
注意：一定要使用strcpy()函数等来操作方法c_str()返回的指针。 c_str()返回一个客户程序可读不可改的指向字符数组的指针，不需要手动释放或删除这个指针。
2、data()：与c_str()类似，但是返回的数组不以空字符终止;
3、copy(p,n,size_type _Off = 0)：从string类型对象中至多复制n个字符到字符指针p指向的空间中。默认从首字符开始，但是也可以指定，开始的位置（记住从0开始）；

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

返回真正从对象中复制的字符。------用户要确保p指向的空间足够保存n个字符

14、string::npos的一些用法总结

string::npos是一个静态成员常量，表示size_t的最大值（Maximum value for size_t）。该值表示”直到字符串结尾“，作为返回值它通常被用作表明没有匹配。
string::npos是这样定义的：

static const size_type npos = -1;

因为string::size_type描述的是size，故需为无符号整数型类别。因为缺省配置为size_t作为size_type，于是-1被转换为无符号整数类型，npos也就成为了该类别的最大无符号值。不过实际值还是取决于size_type的实际定义类型，即无符号整型（unsigned int）的-1与无符号长整型（unsigned long）的-1是不同的。

配合string::find()函数使用

string::find()函数：是一个字符或字符串查找函数，该函数有唯一的返回类型，即string::size_type，即一个无符号整形类型，可能是整数，也可能是长整数。如果查找成功，返回按照查找规则找到的第一个字符或者子串的位置；如果查找失败，返回string::npos，即-1（当然打印出的结果不是-1，而是一个很大的数值，那是因为它是无符号的）。

#include <iostream>
#include <string>

std::string s("1a2b3c4d5e6f7g8h9i1a2b3c4d5e6f7g8ha9i");
void result(const char* p)
{
	std::string::size_type position = s.find(p);

	if (position != std::string::npos)
	{
		std::cout << "Position is : " << position << std::endl;
	}
	else {
		std::cout << "Not found." << std::endl;
	}
}

void result1(const char* p)
{
	size_t position = 0;
	position=s.find(p);
	if (position != std::string::npos)
	{
		std::cout << "Position is : " << position << std::endl;
	}
	else {
		std::cout << "Not found." << std::endl;
	}
}
int main() {

	result("jk");
	result1("b3");
	return 0;
}
//打印结果：
Not found.
Position is : 3