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
”