String常用用法总结

总结string常用函数的常用用法，具体的请看帮助。
头文件：<string>

1、append
描述：在string末尾添加字符串。
string str("Head First");//str:Head First
str.append("!");//str:Head First!

2、assign
描述：给string分配一个新的字符串。
string str("Head First");//str:Head First
str.assign("C++ Primer");//str:C++ Primer

3、at
描述：返回string下标的引用
string str("Head First");//str:Head First
basic_string <char>::reference refStr = str.at (3);//refStr:d

4、capacity，max_size
描述：返回string的容量和最大大小
string str("Head First");//str:Head First
basic_string <char>::size_type capStr, max_sizeStr;
capStr = str.capacity ( );//capStr:15
max_sizeStr = str.max_size ( );//max_sizeStr:4294967294

5、clear
描述：清空string的所有元素
string str("Head First");//str:Head First
str.clear();//str:

6、compare
描述：比较string，相等返回为0，不相等时比较第一个不相同的字符，大于返回为1，小于返回为-1
string str("Head First");//str:Head First
int c = str.compare("Hf");//c:-1

7、copy
描述：拷贝一定数目的字符到目标字符串，返回拷贝数目
string str("Head First");//str:Head First
char ch[20] = {0};
basic_string <char>:: size_type siz = str.copy(ch,6);//siz:6，ch:Head F

8、length
描述：返回字符串的长度
string str("Head First");//str:Head First
basic_string<char>::size_type siz = str.length();//siz:10

9、replace
描述：用另一个字符串的某一段替换当前字符串的某一段内容
string str("Head First");//str:Head First
const char* ch = "Lady";
string str0 = str.replace(0,4,ch);//str0:Lady First

10、data
描述：把string转换成为字符串数组
string str("Head First");//str:Head First
const char* ch = str.data();//ch:Head First

11、end
描述：返回string的最后一个字符后面一个的迭代器
string str("Head First");//str:Head First
basic_string<char>::iterator iteStr = str.end();
iteStr--;//*iteStr:t

12、find
描述：从头查找字符或者子字符串，返回第一个的下标，失败返回npos
string str("Head First");//str:Hesd First
basic_string<char>::size_type index = str.find("i",5);//index:6

13、rfind
描述：从尾部查找字符或者子字符串，返回第一个的下标，失败返回npos
string str("Head First");//str:Hesd First
basic_string<char>::size_type index = str.find("e");//index:1

14、find_first_not_of，find_first_of，find_last_not_of，find_last_of
描述：返回下标，失败返回npos

15、insert
描述：在特定位置插入字符串
string str("Head First");//str:Head First
string str0 = str.insert(0,"C++ ");//str0:C++ Head First

16、empty
描述：判断string是否为空，返回为bool类型

17、swap
描述：交换两个string
string str0("Head First");//str0:Head First
string str1("Lady First");//str1:Lady First
str0.swap(str1);//str0:Lady First,str1:Head First

18、substr
描述：截取子串，参数为起始位置(0)和截取长度(npos)
string str("Head First");//str:Head First
basic_string<char> ch = str.substr(5,3);//ch:First

19、size
描述：返回字符串的大小
string str("Head First");//str:Head First
basic_string<char>::size_type siz = str.size();//siz:10

20、resize
描述：改变string的大小，要么添加要么擦除
string str("Head First");//str:Head First
str.resize(8);//str:Head Fir
str.resize(13,'e');//str:Head Fireeeee

20、reverse
描述：扩大string的容量
string str("Head First");//str:Head First
basic_string <char>::size_type capStr;
capStr = str.capacity();//capStr:15
str.reserve(40);//str:Head First
capStr = str.capacity();//capStr:47

string类的构造函数：
string(const char *s); //用c字符串s初始化
string(int n,char c); //用n个字符c初始化
此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常

string类的字符操作：
const char &operator[](int n)const;
const char &at(int n)const;
char &operator[](int n);
char &at(int n);
operator[]和at()均返回当前字符串中第n个字符的位置，但at函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。
const char *data()const;//返回一个非null终止的c字符数组
const char *c_str()const;//返回一个以null终止的c字符串
int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目

string的特性描述:
int capacity()const; //返回当前容量（即string中不必增加内存即可存放的元素个数）
int max_size()const; //返回string对象中可存放的最大字符串的长度
int size()const; //返回当前字符串的大小
int length()const; //返回当前字符串的长度
bool empty()const; //当前字符串是否为空
void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分

string类的输入输出操作:
string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。
函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'/n'分开。

string的赋值：
string &operator=(const string &s);//把字符串s赋给当前字符串
string &assign(const char *s);//用c类型字符串s赋值
string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值
string &assign(const string &s);//把字符串s赋给当前字符串
string &assign(int n,char c);//用n个字符c赋值给当前字符串
string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串
string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串

string的连接：
string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾
string &append(const char *s); //把c类型字符串s连接到当前字符串结尾
string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾
string &append(const string &s); //同operator+=()
string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
string &append(int n,char c); //在当前字符串结尾添加n个字符c
string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

string的比较：
bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较；
int compare(const string &s) const;//比较当前字符串和s的大小
int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n,const char *s) const;
int compare(int pos, int n,const char *s, int pos2) const;
compare函数在>时返回1，<时返回-1，==时返回0

string的子串：
string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

string的交换：
void swap(string &s2); //交换当前字符串与s2的值

string类的查找函数：

int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//查找成功时返回所在位置，失败返回string::npos的值

int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;
//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值

int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos

int find_first_not_of(char c, int pos = 0) const;
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos,int n) const;
int find_first_not_of(const string &s,int pos = 0) const;
//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos

int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const;

int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s,int pos = npos) const;
//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找

string类的替换函数：

string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串s
string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符
string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串s
string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符
string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符c
string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串s
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符
string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串

string类的插入函数：

string &insert(int p0, const char *s);
string &insert(int p0, const char *s, int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s, int pos, int n);
//前4个函数在p0位置插入字符串s中pos开始的前n个字符
string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
iterator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符
void insert(iterator it, int n, char c);//在it处插入n个字符c


string类的删除函数

iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置
iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置
string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串

string类的迭代器处理：

string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。
用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：
const_iterator begin()const;
iterator begin(); //返回string的起始位置
const_iterator end()const;
iterator end(); //返回string的最后一个字符后面的位置
const_iterator rbegin()const;
iterator rbegin(); //返回string的最后一个字符的位置
const_iterator rend()const;
iterator rend(); //返回string第一个字符位置的前面
rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

字符串流处理：

通过定义ostringstream和istringstream变量实现，<sstream>头文件中
例如：
string input("hello,this is a test");
istringstream is(input);
string s1,s2,s3,s4;
is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"
ostringstream os;
os<<s1<<s2<<s3<<s4;
cout<<os.str();

String用法（一）

basic_string::append

向string 的后面加字符或字符串。(比+=, push_back 更灵活)

(1)向string 的后面加C-string

basic_string& append( const value_type* _Ptr );

string s ( "Hello " ); // s=”Hello ”

const char *c = "Out There ";

s.append ( c ); // s=”Hello Out There”

(2)向string 的后面加C-string 的一部分

basic_string& append( const value_type* _Ptr, size_type _Count );

string s ( "Hello " ); // s=”Hello ”

const char *c = "Out There ";

s.append ( c , 3 ); // s=”Hello Out”

(3)向string 的后面加string(有两种方法)

basic_string& append( const basic_string& _Str );

string s1 ( "Hello " ), s2 ( "Wide " ), s3( "World " );

s1.append ( s2 ); // s1=”Hello Wide”

s1 += s3; // s1=”Hello Wide World”

(4)向string 的后面加string 的一部分 ---A

basic_string& append( const basic_string& _Str, size_type _Off,

size_type _Count );

string s1 ( "Hello " ), s2 ( "Wide World " );

s1.append ( s2 , 5 , 5 ); // s1=”Hello World”

(5)向string 的后面加string 的一部分 ---B

template<class InputIterator> basic_string& append(

InputIterator _First, InputIterator _Last );

string str1f ( "Hello " ), str2f ( "Wide World" );

str1f.append ( str2f.begin ( ) + 5 , str2f.end ( ) );

// s1=”Hello World”

(6)向string 的后面加多个字符

basic_string& append( size_type _Count, value_type _Ch );

string str1e ( "Hello " );

str1e.append ( 4 , '!' ); // s1=”Hello !!!!”

basic_string::assign

给string 赋值。 （比“=”更灵活）

(1)向string 赋C-string

basic_string& assign( const value_type* _Ptr );

string s;

const char *c = "Out There";

s.assign ( c ); // s=”Out There”

(2)向string 赋C-string 的一部分

basic_string& assign( const value_type* _Ptr, size_type _Count );

string s;

const char *c = "Out There";

s.assign ( c , 3 ); // s=”Out”

(3)向string 赋string(有两种方法)

basic_string& assign( const basic_string& _Str );

string s1 ( "Hello" ), s2 ( "Wide" ), s3( "World" );

s1.assign ( s2 ); // s1=”Wide”

s1 = s3; // s1=”World”

(4)向string 赋string 的一部分 ---A

basic_string& assign( const basic_string& _Str, size_type off,

size_type _Count );

string s1 ( "Hello " ), s2 ( "Wide World " );

s1.assign ( s2 , 5 , 5 ); // s1=”Hello World”

(5)向string 赋string 的一部分 ---B

template<class InIt> basic_string& assign(

InputIterator _First,

InputIterator _Last );

string str1f ( "Hello " ), str2f ( "Wide World" );

str1f.assign ( str2f.begin ( ) + 5 , str2f.end ( ) ); // s1=”Wide World”

(6)向string 赋 多个字符

basic_string& assign( size_type _Count, value_type _Ch );

string str1e ( "Hello " );

str1e.assign ( 4 , '!' ); // s1=”!!!!”

String用法（二）

basic_string::compare

如果所比较的两个string 相等，则返回0； 操作string 大于参数string,返回

正数；操作string 小于参数string,返回负数。

(1)比较操作string 与_Str 或C-string_Ptr

int compare( const basic_string& _Str ) const;

int compare( const value_type* _Ptr ) const;

int com = s.compare ( sp );

(2)比较操作string 中_Pos1(下标)开始的_Num1 个字符 与 string_Str

比较操作string 中_Pos1(下标)开始的_Num1 个字符 与 C-string _Ptr

比较操作string 中Pos1(下标)开始的Num1 个字符 与Str 中Off(下标)开始Count 个字

符

int compare( size_type _Pos1, size_type _Num1, const basic_string& _Str );

int compare( size_type _Pos1, size_type _Num1, const value_type* _Ptr ) const;

int compare( size_type _Pos1, size_type _Num1, const basic_string& _Str,

size_type _Off, size_type _Count );

int com1 = s.compare ( 2 , 3 , sp );

int com2 = s.compare ( 2 , 3 , c );

int com3 = s.compare ( 1 , 3 , cs , 3 ,1 );

basic_string::erase

删除string 中的一个或几个元素。前两个成员函数，返回要被删除的子串的下

一个元素的iterator; 第三个函数，返回删除后的string 的引用。

(1)删除string 中从_First 到_Last 的字符

iterator erase( iterator _First, iterator _Last );

basic_string <char>::iterator s_Iter;

s_Iter = s.erase ( s.begin ( ) + 3 , s.end ( ) - 1 ); // s_Iter=s.end( )

(2) 删除string 中_It 所指的字符

iterator erase( iterator _It );

s_Iter = s.erase ( s.begin ( ) + 5 );

(3) 删除string 中从_Pos(下标)开始的_Count 个字符

basic_string& erase( size_type _Pos = 0, size_type _Count = npos );

str = s.erase ( 6 , 8 ); // str 也是string

basic_string::find

寻找给定的string。返回找到的第一个string 下标值；如果没找到则返回npos。

(1)找一个character_Ch。（默认从头找）

size_type find( value_type _Ch, size_type _Off = 0 ) const;

string s ( "Hello Everyone" );

basic_string <char>::size_type index1, index2;

static const basic_string <char>::size_type npos = -1;

index1 = s.find ( "e" , 3 ); // index1=8,不是6

index2 = s.find ( "x" ); // index2=-1

if (indexCh1a != npos ) cout <<indexCh1a << endl;

else cout << "The character 'e' was not found in str1 ." << endl;

(2)找一个C-string。（默认从头找）

size_type find( const value_type* _Ptr, size_type _Off = 0 ) const;

string s ( "Let me make this perfectly clear." );

basic_string <char>::size_type index;

const char *c = "perfect";

index = s.find ( c , 5 ); // index=17

(3)找一个string。（默认从头找）

size_type find( const basic_string& _Str, size_type _Off = 0 ) const;

string s ( "clearly this perfectly unclear." );

basic_string <char>::size_type index;

string sta ( "clear" );

index = s.find ( sta , 5 ); // index=24

String用法（三）

basic_string::max_size

返回string 能放的最大元素个数。（不同于capacity）

size_type max_size( ) const;

basic_string <char>::size_type cap, max;

cap = s.capacity ( );

max = s.max_size ( ); // max=4294967294.

basic_string::rfind

寻找给定的string。返回找到的第一个string 下标值；如果没找到则返回npos。

与find 不同的是：rfind 默认从npos 开始找。其他相同。

basic_string::replace

将原string 中的元素或子串替换。返回替换后的string。

（1）用string 或C-string 代替操作string 中从_Pos1 开始的_Num1 个字符

basic_string& replace( size_type _Pos1,size_type _Num1, const value_type* _Ptr);

basic_string& replace(size_type _Pos1,size_type _Num1,const basic_string_Str);

string a,b;

string s ( "AAAAAAAA" );

string s1p ( "BBB" );

const char* cs1p = "CCC"；

a = s.replace ( 1 , 3 , s1p ); // s=”ABBBAAAA”

b = s.replace ( 5 , 3 , cs1p ); // s=”ABBBACCC”

（2）用string 中从_Pos2 开始的_Num2 个字符,代替操作string 中从_Pos1 开始的_Num1 个字符

用C-string 中的_Num2 个字符，代替操作string 中从_Pos1 开始的_Num1 个字符

basic_string& replace( size_type _Pos1, size_type _Num1, const basic_string& _Str,

size_type _Pos2, size_type );

basic_string& replace( size_type _Pos1, size_type _Num1,

const value_type* _Ptr, size_type _Num2 );

string a, b;

string s ( "AAAAAAAA" );

string s2p ( "BBB" );

const char* cs2p = "CCC";

a = s.replace ( 1 , 3 , s2p , 1 , 2 ); // s=”ABBAAAA”

b = s.replace ( 4 , 3 , cs2p , 1 ); // s=”ABBAC”

（3）用_Count 个character_Ch ,代替操作string 中从_Pos1 开始的_Num1 个字符

basic_string& replace( size_type _Pos1, size_type _Num1,

size_type_Count, value_type_Ch );

string result;

string s ( "AAAAAAAA" );

char ch = 'C';

result = s.replace ( 1 , 3 , 4 , ch ); // s=”ACCCCAAAA”

（4）用string 或C-string ,代替操作string 中从First0 到Last0 的字符

basic_string&replace(iterator First0,iterator Last0, const basic_string& _Str);

basic_string&replace(iterator First0,iterator _Last0, const value_type* _Ptr);

string s ( "AAAAAAAA" ); string s4p ( "BBB" );

const char* cs4p = "CCC";

basic_string<char>::iterator IterF0, IterL0;

IterF0 = s.begin ( ); IterL0 = s.begin ( ) + 3;

string a, b;

a = s.replace ( IterF0 , IterL0 , s4p ); // s=”BBBAAAAA”

b = s.replace ( IterF0 , IterL0 , cs4p ); // s=”CCCAAAAA”

（5）用string 中从_Pos2 开始的_Num2 个字符,代替操作string 中从First0 到Last0 的字符

用C-string 中的_Num2 个字符，代替操作string 中从First0 到Last0 的字符

basic_string& replace( iterator _First0, iterator _Last0,

const value_type* _Ptr, size_type _Num2 );

template<class InputIterator> basic_string& replace(

iterator _First0, iterator _Last0,

InputIterator _First, InputIterator _Last );

IterF3 = s.begin ( ) + 1; IterL3 = s.begin ( ) + 3;

IterF4 = s.begin ( ); IterL4 = s.begin ( ) + 2;

a = s.replace ( IterF3 , IterL3 , IterF4 , IterL4 );

b = s.replace ( IterF1 , IterL1 , cs5p , 4 );

（6）用_Count 个character_Ch ,代替操作string 中从First0 到Last0 的字符

basic_string& replace( iterator _First0, iterator _Last0,

size_type _Count , value_type _Ch );

a = s.replace ( IterF2 , IterL2 , 4 , ch );

basic_string::swap

交换两个string。

void swap( basic_string& _Str );

s1.swap ( s2 );

basic_string::substr

返回从_Off(下标)开始的_Count 个字符组成的string

basic_string substr( size_type _Off = 0, size_type _Count = npos ) const;

string s("I love you!")， sub;

sub=s.substr( ); // sub=”I love you!”

sub=s.substr(1); // sub=” love you!”

sub=s.substr(3,4); // sub=”ove ”