c++笔记_标准库类型string

---

一、标准类型库string

标准类型库string表示可变长的字符序列，使用string类型必须首先包含string头文件。

#include<string>
using std::string;

作为标准库的一部分，string定义在命名空间std中。

二、定义和初始化string对象

1.string构造函数

以下是string的构造函数：

string();		//创建一个空字符串，例如string str1;
string(const string &str);		//使用一个string对象初始化另一个string对象
string(const char* s);			//使用字符串s初始化
string(int n,char c);			//使用n个字符c初始化

分别使用上面的构造函数进行初始化：

#include <string>
using namespace std;
int main(void)
{
	//使用string()初始化
	string s1;			//默认初始化，s1是一个空字符串
	
	//string(const char* s)初始化
	string s2("字符串");		//s2是字面值"字符串"的副本，除了字面值最后的那个空字符串外(\0);
	string s5 = "字符串";	//等价于s2("字符串")
	
	//使用string(int n,char c)初始化
	string s3(10,'a');		//使用10个字符a初始化，输出：aaaaaaaaaa
	
	//使用string(const string &str)初始化
	string s4(s2);  		//s4是s2的副本，输出：字符串
	
	return 0;
}

2.直接初始化和拷贝初始化

C++语言有几种不同初始化的方式：

1.拷贝初始化：如果使用等号(=)初始化一个变量，实际上执行的是拷贝初始化，编译器把等号右侧的初始化值拷贝到新创建的对象中去。

2.直接初始化：与拷贝初始化相反如果不使用等号，则执行的是直接初始化。

string s5 = "hiya";		//拷贝初始化
string s6("hiya");		//直接初始化
string s7(10,'c');		//直接初始化

当初始值只有一个时，使用直接初始化或拷贝初始化都行。如果像上面s7那样初始化要用到的值有多个，一般来说只能使用直接初始化。

对于用多个值进行初始化的情况，非要用拷贝初始化的方式来处理也不是不可以，不过需要显示地创建一个（临时）对象用于拷贝：

string s8 = string(10,'c');		//拷贝初始化，s8的内容是ccccccccc

实际上是用数字10和字符c两个参数创建出来的一个string对象，然后这个string对象又拷贝给了s8。上面语句等价于下面的两条语句：

//等价于string s8 = string(10,'c')
string temp(10,'c');
string v_temp = temp;		//将temp的内容拷贝给v_temp

3.string基本赋值操作

一个类除了要规定初始化其对象的方式外，还要定义对象上所能执行的操作。

以下列出string的基本赋值操作方法：

string& operator=(const char *s);	//char*类型字符串赋值给当前的字符串
string& operator=(const string &s);	//把字符串s赋值给当前的字符串
string& operator=(char c);			//字符赋值给当前的字符串
string& assign(const char *s);		//把字符串s赋给当前的字符串
string& assign(const char*s,int n);	//把字符串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个

分别使用上面的方法进行赋值：

#include<string>
#include<iostream>
using namespace std;
int main(void)
{
	string s1("Hello World");		//初始化s1对象
	
	//使用方法string& operator=(const string &s)
	string s2;
	s2 = s1;
	cout<<s1<<endl;		//输出Hello World

	//使用方法string& operator=(const char *s)
	string s3;
	s3 = "Hello World";
	cout<<s3<<endl;		//输出Hello World

	//使用方法string& operator=(char c)
	string s4;
	s4 = 'H';
	cout<<s4<<endl;		//输出H
	
	//使用string& assign(const char *s)
	string s5;
	s5.assign("Hello World");
	cout<<s5<<endl;		//输出Hello World

	//使用方法string& assign(const char*s,int n)
	string s6;
	s6.assign("Hello World",5);
	coutt<<s6<<endl;	//输出Hello

	//使用方法string& assign(const string &s)
	string s7;
	s7.assgin(s1);
	cout<<s7<<endl;		//输出Hello World

	//使用方法string& assign(int n,char c)
	string s8;
	s8.assign(10,'w');
	cout<<s8<<endl;		//输出wwwwwwwwww

	//使用方法string& assign(const string &s,int start,int n)
	string s9;
	s9.assgin("aaaabbbbcccc",4,6);
	cout<<s9<<endl;		//输出bbbccc
		
	return 0;
}

4.读写string对象

可以使用标准库中的iostream来读写stirng对象：

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string str1;
	cin>>str1;			//将string对象读入str1，遇到空白为止
	cout<<str1<<endl;	//输出s
	
	//string对象可以多个输入或者多个输出连写在一起
	string s1,s2;
	cin>>s1>>s2;		//把第一个输入读到s1中，第二个输入读到s2中
	cout<<s1<<s2<<endl;	//输出两个string对象
	return 0;
}

在执行读取操作时，string对象会自动忽略开头的空白（即空格符、换行符、制表符等）并从第一个真正的字符开始读起，直到遇见下一处空白。

比如str1输入的是“ aaa bbb ”（注意开头和结尾处的空格），那么输出的是“aaa”，输出结果不会有空格。

比如s1，s2分别输入“ aaa bbb ”，那么输出的是“aaabbb”。

5.使用getline读取一整行

有时候我们希望能在最终得到的字符串保留输入的空白符，这时应使用getline函数代替原来的>>运算符。

getline函数的参数是一个输入流和一个string对象，函数从给定的输入流中读入内容，直到遇到换行符为止（换行符也会被读入），然后把读入的内容存入到string对象中（不会存换行符）。因此getline只要一遇到换行符就会结束读取操作并返回结果，哪怕输入的一开始是换行符也是如此。

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string s1;
	//每次读入一整行，直至达到文件末尾
	while(getline(cin,s1))
		cout<<s1<<endl;
	return 0;
}

因为s1中不包含换行符，所以我们手动加上换行符操作。和往常一样，使用endl结束当前并刷新显示缓冲区。

6.string的empty和size操作

empty函数根据string对象是否为空返回一个对应的布尔值。如果为空则返回true：

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string s1;
	if(s1.empty()==true)
	{
		cout<<"s1没有任何内容"<<endl;
	}else
	{
		cout<<s1<<endl;
	}
	return 0;
}

代码输出：

s1没有任何内容		

s1对象是个空字符串，所以empty函数返回true，因此输出"s1没有任何内容"。

size函数返回string对象的长度（即string对象中字符的个数）:

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string s1("hello world");
	cout<<"s1字符串字数是："<<s1.size()<<endl;	//输出：s1字符串字数是：11
	return 0;
}

由于size函数返回的是一个无符号整型数，因此切记，如果在表达式中混用了带符号数和无符号数将可能产生意想不到的结果。例如，假设n是一个具有负值的int，则表达式s.size()<n的判断结果几乎肯定是true。这是因为负值n会自动转换成一个比较大的无符号值。

所以如果一条表达式中已经有了size()函数就不要再使用int了。

7.比较string对象

string类定义了几种用于比较字符串的运算符。这些比较运算符逐一比较string对象中的字符，并且对大小写敏感，也就是说，在比较同一个字母的大写形式和小写形式是不同的。

不过这些运算符都依照（大小写敏感的）字典顺序：
1.两个string对象的长度不同，并且较短的string对象的每个字符都与较长string对象对应位置上的字符相同，较短string对象小于较长string对象。

2.如果两个string对象在某些对应的位置上不一致，则string对象比较的结果其实是string对象中第一个相异字符比较的结果。

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string s1 = "Hello";
	string s2 = "Hello World";
	string s3 = "Hiya";
	return 0;
}

根据上面的规则1判断，对象s1小于对象s2；根据规则2可判断，对象s3大于s1和s3。

8.两个string对象相加

两个string对象相加得到一个新的string对象，其内容就是把左侧的运算对象与右侧的运算对象拼接而成：

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string s1 = "Hello";
	string s2 = "World";
	string s3 = s1 + s2;
	cout<<s3<<endl; 	//输出HelloWorld
	return 0;
}

也可以使用+=或append方法进行拼接：

string& operator+=(const string &str);//重载+=操作符
string& operator+=(const char *str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& append(const char *s);//把字符串s连接到当前字符串结尾
string& append(const char *s,int n);//把字符串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个字符

分别使用上述方法拼接：

#include<iostream>
#include<string>
using namespace std;
int main(void)
{
	string str1="hello";
	string str2="string";
	//string& operator+=(const string &str);//重载+=操作符  
	str1+=str2;
	cout<<str1<<endl;	//"hellostring"
	
	string str3="hello";
	//string& operator+=(const char *str);//重载+=操作符
	str3+="string";
	cout<<str3<<endl;	//"hellostring"
	
	string str4="hello";
	//string& append(const char *s,int n);//把字符串s的前n个字符连接到当前字符串结尾
	str4.append("hehehaha",4);
	cout<<str4<<endl;		//"hellohehe"
	
	//string& append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
	string str5="hello";
	string str6="hehehahaha";
	str5.append(str6,4,6);
	cout<<str6<<endl;	//"hellohahaha
	
	return 0;
}

当把string对象和字符字面值及字符串字面值混在一条语句使用时，必须确保每个加法运算符(+)的两侧的运算对象至少有一个是string:

string s1("hello");
string s4 = s1 + ",";		//正确：把一个string对象和一个字面值相加
string s5 = "hello" +",";	//错误：两个运算对象都不是string 

//正确：每个加法运算符都又一个运算对象是string
string s6 = s1 + "," + "world";	
string s7 = "hello"+"," +s1;	//错误：不能把字面值直接相加，反过来是s1 + "hello" +",";就可以

只要记得C++语言中的字符串字面值并不是标准库类型string的对象，即字符串字面值与string是不同的类型。一般就不会出错。

9.string的查找替换

string查找替换方法：

int find(const string &str,int pos=0) const;//查找str第一次出现位置,从pos开始查找
int find(const char *s,int pos=0) const;//查找s第一次出现位置,从pos开始查找
int find(const char *s,int pos,int n) const;//从pos位置查找s的前n个字符第一次位置
int find(const char c,int pos=0) const;//查找字符c第一次出现位置
int rfind(const string &str,int pos = npos) const;//查找str最后一次位置,从pos开始查找
int rfind(const char *s,int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
int rfind(const char *s,int pos,int n) const;//从pos查找s的前n个字符最后一次位置
int rfind(const char c,int pos = 0) const;//查找字符c最后一次出现位置
string& replace(int pos,int n,const string &str);//替换从pos开始n个字符为字符串
string& replace(int pos,int n,const char *s);//替换从pos开始的n个字符为字符串s

查找替换方法案例：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
int main(void)
{
	//字符串元素默认从0开始计算
	
	//使用int find(const string &str,int pos=0) const;//查找str第一次出现位置,从pos开始查找
	string s1 = "aaa:bbb:ccc:ddd";
	string tmp = "ddd";
	//从s1字符串寻找ddd，默认从0位置开始找（即a开始找）
	cout<<s1.find(tmp)<<endl;			//输出12	
	cout<<s1.find(tmp,4)<<endl;		//从第四个字符开始找即b开始找，输出12
	
	//使用int find(const char *s,int pos=0) const;//查找s第一次出现位置,从pos开始查找
	cout<<s1.find("aa")<<endl;			//输出0	
	cout<<s1.find("ddd",4)<<endl;		//从第四个字符开始找即b开始找，输出12

	//使用string& replace(int pos,int n,const char *s);//替换从pos开始的n个字符为字符串s
	//从第4个字符开始把3个字符替换成***	
	cout<<s1.replace(4,3,"***")<<endl;				//输出aaa:***:ccc:ddd

	//需求：将字符串中所有a的字符替换成*
    string s2 = "www.aabbcafa.com";
    int tmp = 0;                //存放找到的返回值
    string target="a";            //定义目标字符a
    int pow = 0;
    while(pow<=s2.size())
    {
        tmp = s2.find(target);
        if(tmp>0)
        {
            s2.replace(tmp,strlen("a"),"*");
            pow+=1;
        }   
        pow+=1;
    }
    cout<<s2<<endl;		//输出www.**bbc*f*.com
	return 0;
}

10.string的字符串比较

string字符串可以进行比较，以下是比较方法：

1.compare函数在>时返回1，<时返回‐1，==时返回0。
2.比较区分大小写，比较时参考字典顺序，排越前面的越小。
3.大写的A比小写的a小。
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较

方法使用案例：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
int main(void)
{	
	//比较s1和s2的字符大小
	string s1 = "hehe";
	string s2 = "haha";

	//int compare(const string &s) const;//与字符串s比较
	cout<<s1.compare(s2)<<endl;			//输出：1
	
	//int compare(const char *s) const;//与字符串s比较
	cout<<s1.compare("lala")<<endl;		//输出：-1
	cout<<s1.compare("hehe")<<endl;		//输出：0
	
	return 0;
}

11.string的字符串提取

我们可以提取字符串中的某些字符，具体方法：

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

方法使用案例：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
int main(void)
{	
	string s1 = "aaa:bbb:ccc:ddd";
	//从0开始计算提取4个字符
	cout<<s1.substr(0,4)<<endl;		//输出aaa:

	//案例：将:分割的所有字符串提取出来
	string s1 = "aaa:bbb:ccc:ddd";
    string s2;
    int pos = 0;        //提取位置
    int rew = 0;        //字符:的位置
    while(1)
    {
        rew = s1.find(":",pos);
        if(rew<0)
        {
            s2 = s1.substr(pos,s1.size()-pos);
            cout<<s2<<endl;
            break;
        }    
        s2 = s1.substr(pos,rew-pos);
        cout<<s2<<endl;
        pos=rew+1;           
    }
	return 0;
}

12.string的字符串插入删除

我们可以对字符串进行插入删除操作，具体方法：

string& insert(int pos,const char *s);//插入字符串
string& insert(int pos,const string &str);//插入字符串
string& insert(int pos,int n,char c);//在指定位置插入n个字符c
string& erase(int pos,int n = npos);//删除从Pos开始的n个字符	

方法使用案例：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
int main(void)
{	
	string str1 = "helloworld";
	
	str1.insert(5,"hehe");
	cout<<str1<<endl;	//输出：helloheheworld
	
	str1.erase(5,4);	//删除字符串中hehe
	cout<<str1<<endl;	//输出：helloworld
	
	//清空字符串str1.size()得到字符串的总大	
	str1.erase(0,str1.size());
	cout<<str1.size()<<endl;	//输出：0

	return 0;
}

13.string和c风格的字符串转换

我们可以将c风格的字符串直接转弯成string类型，相反不能将string类型直接转换成c风格的字符串，要转换必须使用c_str方法完成：

#include<iostream>
#include<string>
#include<string.h>
using namespace std;
int main(void)
{	
	string str1;//对象
	char *str2 = "hellostr";
	//将char*转成string（直接完成）	 
	str1 = str2;
	cout<<str1<<endl;	//输出：hellostr
	
	string str3 = "hellostr3";
	//不能直接将string转换成char*必须借助string中的c_str方法完成
	//char *str4 =str3; 	//错误，无法将string转换成char*
	char *str4 = const_cast<char*>(str3.c_str());
	cout<<str4<<endl;		//输出:hellostr3

	return 0;
}

---

总结

不容易，终于写完，以上是有关于string类库的方法及使用案例。可以收藏下哈哈哈