C++快速上手string的使用，刨析string常用成员函数，体验到C++的快乐。

1、C++中string的简介

1. string是表示字符串的字符串类，在C++中有了string类的帮助，对于字符串的处理可以说是事半功倍。
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string string;
4. 不能操作多字节或者变长字符的序列。
5. 在使用string类时，必须包含#include头文件以及using namespace std。

注意：本文的目的是为了让新手更快的上手string类的使用，所以对于string类的成员方法，详细讲解一些常用的成员方法为主，旨在大家快速全面的使用string。

2、string类常用的构造函数

//1、不传任何值的构造
构造函数：string();
//用法：直接构造，不需要传任何参数。
例：string s1;

//2、拷贝构造
构造函数：string(const string& str);
//用法：拷贝一个已经存在的string类给当前所要构造的类。
例：string s2(s1);

//3、利用字符串构造
构造函数：string(const char* s);
//用法：传递一个常量字符串，进行构造。
例：string s3("hello world");

3、赋值运算符重载

1、string& operator= (const string& str);
//用法：利用已经存在的string对象进行赋值
//例：
string s1("hello");
string s2("hi");
s1=s2;//此时会形成赋值运算符的重载，自动调用string& operator= (const string& str)

2、string& operator= (const char* s);
//用法：利用常量字符串对已经存在的string对象进行赋值
//例：
string s1;
s1 = "hello";//此时会形成赋值运算符的重载，自动调用string& operator= (const char* s)

3、string& operator= (char c);
//用法：利用字符对已经存在的string对象进行赋值
//例：
string s1;
s1 = "s";//此时会形成赋值运算符的重载，自动调用string& operator= (char c)

4、容量相关成员函数

1、string容量大小相关函数

1、size_t size() const;//返回有效元素的个数
2、size_t length() const;//返回有效元素的长度(返回有效元素的个数)
注意：这两个函数的意义可以看成相等，但是在日常使用的过程
中强烈推荐大家使用size(),该函数和STL容器中接口相一致。
3、size_t max_size() const;//返回字符串的最大大小
4、size_t capacity() const;//返回字符串的容量

//上述函数的使用举例
//一定要引头文件，并展开using namespace std;
#include
#include
using namespace std;
int main()
{
	string str("hello");
	str.size();
	str.length();
	str.max_size();
	str.capacity();
	return 0;
}

2、string扩充容量的函数

1、void reserve (size_t n = 0);
n为所要开辟空间大小，默认为0
如果n小于原对象的容量，不会对原对象造成任何影响。
如果n大于原对象的容量，保留原先的内容，容量大小扩充到n。
2、void resize (size_t n);
   void resize (size_t n, char c);
n为所要开辟空间大小，默认为0
如果n小于原对象的容量，有效字符的个数缩小到n，容量不变。
如果n大于原对象的容量，保留原先的内容，容量大小扩充到n，原内容后的字符都进行初始化。

//上述函数的使用举例
int main()
{
	string str("hello");
	str.reserve(100);//容量扩充到100
	string str2;
	str2.resize(100,'x');//容量扩充到100，并且初始化为x
	return 0;
}

3、清楚有效字符

void clear();
清楚掉string对象的有效字符，但是不会影响容量

4、判定对象是否为空

bool empty() const;
如果有效字符的个数为零返回真，反正返回假。

5、对单个元素的访问

1、char& operator[] (size_t pos);
2、const char& operator[] (size_t pos) const;
//上述两个函数是对[]运算符的重载，通过下标返回字符元素
//函数1对应普通对象的调用
//函数2对应const对象的调用
//上述函数的使用举例
int main()
{
	string str("hello");
	str[0]='s';//将h修改为s
	cout<<str[2];//输出l
	return 0;
}

6、 push_back在字符末尾追加一个字符

void push_back (char c);

//上述函数的使用举例
int main()
{
	string str("hello");
	str.push_back('w');
	str.push_back('o');
	str.push_back('r');
	//push_back一次只能追加一个字符
	return 0;
}

7、append在字符末尾追加一个字符串或string对象

该函数在底层实现时，重载了多种版本，如下所示，但是在此只对1和3进行重点刨析。

1、string (1)
//在string对象末尾追加一个string对象	
string& append (const string& str);
2、substring (2)	
string& append (const string& str, size_t subpos, size_t sublen);
3、c-string (3)	
//在string对象末尾追加一个字符串
string& append (const char* s);
4、buffer (4)	
string& append (const char* s, size_t n);
5、fill (5)	
string& append (size_t n, char c);
6、range (6)	
template <class InputIterator>
   string& append (InputIterator first, InputIterator last);

//上述函数的使用举例
int main()
{
	string str1("hello");
	str1.append("world");
	
	string str2("hello");
	string wd("world");
	str2.append(wd);
	return 0;
}

8、+=的使用（强烈推荐）

1、在末尾追加一个string类对象
string& operator+= (const string& str);
2、在末尾追加一个字符串
string& operator+= (const char* s);
3、在末尾追加一个字符
string& operator+= (char c);

//使用样例
int main()
{
	string str("hell");
	str+='o';//追加一个字符
	string sub("wo");
	str+=sub;//追加一个string类对象
	str+="rld";//追加一个字符串
	return 0;
}

9、insert、erase及pop_back的使用

注意：insert在使用的过程中效率较低，一般推荐对字符串中间以前部分进行不断的数据插入。

//1、在pos位置前插入一个string类对象
string& insert (size_t pos, const string& str);
//2、在pos位置前插入一个字符串
string& insert (size_t pos, const char* s);
//3、从pos位置开始，删除len个长度的字符
string& erase (size_t pos = 0, size_t len = npos);
//4、删除尾部的一个字符，但是该函数是C++11中才出现的，使用时一定要注意C++的版本
void pop_back();
//使用样例
int main()
{
	string str("hell");
	string ins("insert");
	str.insert(str.begin()+2,ins);
	str.insert(str.begin()+3,"sja");
	str.erase(str.begin,10);
	str.pop_back();
	return 0;
}

10、string中的swap与算法函数中的swap的区别。

首先建议string对象进行交换的时候，使用string类里面自带的swap来进行交换，因为算法函数中的swap在交换的时候进行了三次深拷贝，这个过程中效率会大大降低。

11、string迭代器的使用

先来说一下迭代器是什么。迭代器一般多为指针的封装或者直接是原生的指针，在string中的迭代器就可以看成是原生的指针，下面来看一下迭代器的使用。

//1、返回一个指向字符串第一个字符的迭代器。
iterator begin();//普通类对象版本
const_iterator begin() const;//const类对象版本
//2、返回一个指向字符串最后一个字符的下一个位置的迭代器。
iterator end();//普通类对象版本
const_iterator end() const;//const类对象版本


//例：迭代器的使用
int main()
{
	
	string str("hello");
	string::iterator it=str.begin*();
	//利用迭代器遍历字符串
	while(it!=str.end())
	{
		cout<<*it<<endl;
		++it;
	}
	//利用迭代器修改字符串
	//const类型的迭代器不可进行修改
	while(it!=str.end())
	{
		(*it)+=1;
		++it;
	}
	return 0;
}

12、string中查找子串，find的使用

在了解find前，先来了解一下npos，npos是定义在string类中的一个类型为size_t的全局变量，并且赋值为-1，但是代表的是一个整型的最大值为4,294,967,295。当find查找成功时，返回查找对象的首位置的下标，当失败的时候返回npos。

//1、在string对象中查找一个子对象
size_t find (const string& str, size_t pos = 0) const;
//str代表要查找的子对象，pos代表从主对象的那个位置开始查找，默认从开头进行

//2、在string对象中查找一个字符串
size_t find (const char* s, size_t pos = 0) const;
//s代表要查找的字符串，pos代表从主对象的那个位置开始查找，默认从开头进行

13、字符串切割，substr的使用

string substr (size_t pos = 0, size_t len = npos) const;
//pos代表从string对象的那个位置开始，默认为0；len代表要切割的长度，默认值为npos
//若切割的长度大于该字符串长度，则直至到末尾结束。