C++ 标准库类型string

C/C++总述：Study C/C++-CSDN博客 

目录

定义和初始化string对象 

string的增

使用push_back进行尾插

使用insert插入 

使用append函数完成string的拼接

string的删

使用pop_back进行尾删

使用erase删除

string的查

使用find函数正向搜索第一个匹配项

使用rfind函数反向搜索第一个匹配项

使用compare函数完成比较

string的改

使用replace函数完成string的替换

​编辑

使用swap函数完成两个string类的交换

string的大小和容量 

使用size函数或length函数获取当前有效字符的个数

使用max_size函数获取string对象对多可包含的字符数

使用capacity函数获取当前对象所分配的存储空间的大小

使用resize改变当前对象的有效字符的个数

使用reserve改变当前对象的容量大小

使用clear删除对象的内容，删除后对象变为空字符串

使用empty判断对象是否为空

string中元素的访问

[ ]+下标

使用at访问对象中的元素

使用范围for访问对象中的元素

使用迭代器访问对象中的元素

迭代器的实现 

string中与迭代器相关的函数

与正向迭代器相关的函数

与反向迭代器相关的函数

string与字符串之间的转换

将字符串转换为string

使用c_str或data将string转换为字符串

string中子字符串的提取

使用substr函数提取string中的子字符串

使用copy函数将string的子字符串复制到字符数组中

getline函数

---

标准库类型 string 表示可变长的字符序列，使用 string 类型必须首先包含 string 头文件。作为标准库的一部分，string 定义在命名空间 std 中。

#include <string>
using std::string;

定义和初始化string对象 

string (1) 复制赋值操作符	string& operator= (const string& str);
c-string (2) C字符串赋值操作符	string& operator= (const char* s);
character (3) 单个字符赋值操作符	string& operator= (char c);
initializer list (4) 初始化列表赋值操作符	string& operator= (initializer_list<char> il);
move (5) 移动赋值操作符	string& operator= (string&& str) noexcept;

/*复制赋值操作符 (Copy Assignment Operator): 复制赋值操作符 = 用于将另一个string对象的内容复制到当前对象中。如果可能的话，它应该删除当前对象中已有的内容，并分配新的内存来存储复制的数据。*/
string& operator= (const string& str) {// 删除当前字符串的内容delete[] data;// 分配新的内存并复制内容size = str.size;capacity = str.capacity;data = new char[capacity];memcpy(data, str.data, size);return *this;
}
/*C字符串赋值操作符 (C-String Assignment Operator): 当一个string对象被赋值为一个C风格的字符串（char*类型）时，这个操作符被用来将C字符串的内容转换为string对象。*/
string& operator= (const char* s) {// 删除当前字符串的内容delete[] data;// 初始化大小和容量size = strlen(s);capacity = size; // 假设s字符串长度不会超过预期// 分配内存并复制内容data = new char[capacity];memcpy(data, s, size);return *this;
}
/*单个字符赋值操作符 (Single Character Assignment Operator): 这个操作符允许将一个字符赋值给string对象， effectively将字符串的内容替换为该字符。*/
string& operator= (char c) {// 删除当前字符串的内容delete[] data;// 初始化大小和容量size = 1;capacity = 1;// 分配内存并复制内容data = new char[capacity];data[0] = c;return *this;
}
/*初始化列表赋值操作符 (Initializer List Assignment Operator): 使用initializer_list<char>可以高效地初始化string对象，特别是当字符串很大，且全部内容已知时。*/
string& operator= (initializer_list<char> il) {// 删除当前字符串的内容delete[] data;// 初始化大小和容量size = il.size();capacity = size; // 假设初始化列表长度不会超过预期// 分配内存并复制内容data = new char[capacity];std::copy(il.begin(), il.end(), data);return *this;
}
/*移动赋值操作符 (Move Assignment Operator): move操作符用于高效地转移资源，如内存分配给当前对象，而释放掉传递给操作符的string对象的资源。*/
string& operator= (string&& str) noexcept {// 交换数据成员，这里假设data是一个指针，size和capacity是相应的尺寸和容量变量std::swap(data, str.data);std::swap(size, str.size);std::swap(capacity, str.capacity);return *this;
}

string的增

使用push_back进行尾插

void push_back (char c);

eg:

int main()
{string s1;s1.push_back('C');s1.push_back('S');s1.push_back('D');s1.push_back('N');return 0;
}

使用insert插入 

string& insert (size_t pos, const string& str);	//在pos位置上插入string对象
string& insert (size_t pos, const char* s);		//在pos位置上插入字符串
iterator insert (iterator p, char c);			//在迭代器p的位置上插入字符c

 eg:

#include <iostream>
#include <string>
using namespace std;
int main()
{string s("C"); //C//insert(pos, str)在pos位置插入字符串strs.insert(1, "S"); //CS//insert(pos, string)在pos位置插入string对象string t("D");s.insert(2, t); //CSD//insert(pos, char)在pos位置插入字符chars.insert(s.end(), 'N'); //CSDNcout << s << endl; //CSDNreturn 0;
}

 

使用append函数完成string的拼接

string& append (const string& str);	  //在字符串尾部追加字符串str
string& append (const char* s);		  //在字符串尾部追加C风格的字符串s
string& append (size_t n, char c);	  //将字符c重复追加n次到调用该函数的字符串对象的尾部。

eg:

	string s1("Hello");string s2("World");//"Hello"s1.append(s2);		//在字符串尾部追加字符串str//"Hello World"s1.append(" ");		//在字符串尾部追加C风格的字符串s//"Hello World "s1.append(3, '!');	//将字符'!'重复追加3次到调用该函数的字符串对象的尾部。//"Hello World !!!"return 0;

 

string的删

使用pop_back进行尾删

void pop_back();

eg:

int main()
{string s1("Hello World");s1.pop_back();//Hello Worlds1.pop_back();//Hello Worls1.pop_back();//Hello Worreturn 0;
}

使用erase删除

string& erase (size_t pos = 0, size_t len = npos);	//删除pos位置开始的n个字符
iterator erase (iterator p);	//删除pos位置的字符
iterator erase (iterator first, iterator last);//删除[pos1，pos2)上所有字符

eg:

int main()
{    string s1("Hello World");//Hello Worlds1.erase(6, 3);		//erase(pos, n)删除pos位置开始的n个字符//Hello lds1.erase(s1.end() - 2);	//erase(pos)删除pos位置的字符//Hello ds1.erase(s1.begin() + 1, s1.begin() + 3);	//erase(pos1, pos2)删除[pos1,pos2)上所有字符//Hlo dreturn 0;
}

string的查

使用find函数正向搜索第一个匹配项

size_t find (const string& str, size_t pos = 0) const;
/*在调用该函数的字符串对象中查找目标字符串str，可选参数pos表示查找起始位置，
默认从字符串开头开始查找。*/size_t find (const char* s, size_t pos = 0) const;
/*在调用该函数的字符串对象中查找以null结尾的C风格字符串s，可选参数pos表示查找起始位置，
默认从字符串开头开始查找。*/size_t find (char c, size_t pos = 0) const;
/*在调用该函数的字符串对象中查找目标字符c，可选参数pos表示查找起始位置，
默认从字符串开头开始查找。*/

eg:

    string s1("http://www.cplusplus.com/reference/string/string/find/");//find(string)正向搜索与string对象所匹配的第一个位置string s2("www");size_t pos1 = s1.find(s2);cout << pos1 << endl; //7//find(str)正向搜索与字符串str所匹配的第一个位置char str[] = "cplusplus.com";size_t pos2 = s1.find(str);cout << pos2 << endl;  //11//find(char)正向搜索与字符char所匹配的第一个位置size_t pos3 = s1.find(':');cout << pos3 << endl; //4

使用rfind函数反向搜索第一个匹配项

size_t rfind (const string& str, size_t pos = npos) const;
/*从字符串末尾开始向前查找目标字符串str，可选参数pos表示查找起始位置，
默认从字符串开头开始查找。*/size_t rfind (const char* s, size_t pos = npos) const;
/*从字符串末尾开始向前查找以null结尾的C风格字符串s，可选参数pos表示
查找起始位置，默认从字符串开头开始查找。*/size_t rfind (char c, size_t pos = npos) const;
/*从字符串末尾开始向前查找目标字符c，可选参数pos表示查找起始位置，
默认从字符串开头开始查找。*/

eg:

    string s1("http://www.cplusplus.com/reference/string/string/find/");//rfind(string)反向搜索与string对象所匹配的第一个位置string s2("string");size_t pos1 = s1.rfind(s2);cout << pos1 << endl; //42//rfind(str)反向搜索与字符串str所匹配的第一个位置char str[] = "reference";size_t pos2 = s1.rfind(str);cout << pos2 << endl;  //25//rfind(char)反向搜索与字符char所匹配的第一个位置size_t pos3 = s1.rfind('/');cout << pos3 << endl; //53

使用compare函数完成比较

int compare (const string& str) const;
//比较调用函数的字符串对象和参数字符串对象 str 的大小关系。int compare (size_t pos, size_t len, const string& str) const;
//比较调用函数的字符串对象从指定位置开始的子串和参数字符串对象 str 的大小关系。int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
/*比较调用函数的字符串对象从指定位置开始的子串（长度为 len）和参数字符串对象 str 的子串（从 subpos 开始，长度为 sublen）的大小关系。*/

如果调用函数的字符串小于参数字符串，则返回负值。

如果调用函数的字符串等于参数字符串，则返回零。

如果调用函数的字符串大于参数字符串，则返回正值。

eg:

    string s1("hello world");string s2("hello CSDN");//"hello world"和"hello CSDN"比较cout << s1.compare(s2) << endl; //1//"ell"和"hello CSDN"比较cout << s1.compare(1, 3, s2) << endl; //-1//"hello"和"hello"比较cout << s1.compare(0, 4, s2, 0, 4) << endl; //0

string的改

使用replace函数完成string的替换

string& replace (size_t pos, size_t len, const char* s);
string& replace (size_t pos, size_t len, size_t n, char c);

eg:

    string s("hello world");//replace(pos, len, str)将pos位置开始的len个字符替换为字符串strs.replace(0, 4, "HELLO"); //HELLOo world//replace(pos, len, n, char)将pos位置开始的len个字符替换为n个字符chars.replace(10, 3, 3, '!'); //HELLOo wor!!!

使用swap函数完成两个string类的交换

void swap (string& x, string& y);
void swap (string& str);

eg:

	string s1("Hello");string s2("World");string s3("gghhh");//void swap (string& x, string& y);s1.swap(s2);//void swap (string& str);swap(s2, s3);

string的大小和容量 

使用size函数或length函数获取当前有效字符的个数

size_t size() const;
size_t length() const;

eg:

	string s1("Hello");string s2("World");auto size = s1.size();		//5auto length = s2.length();	//5

使用max_size函数获取string对象对多可包含的字符数

size_t max_size() const;

eg:

int main()
{string s("GH");cout << s.max_size() << endl; //9223372036854775807return 0;
}

使用capacity函数获取当前对象所分配的存储空间的大小

size_t capacity() const;

eg:

	string s1("Hello World");cout << s1.capacity() << endl;		//15

使用resize改变当前对象的有效字符的个数

void resize (size_t n);
void resize (size_t n, char c);

当n大于size时，若给出字符c，则用c来填充，否则用‘\0’来填充.

当n小于size时，则将size缩小到n

eg:

    string s1("CSDN");s1.resize(6, '!');		//CSDN!!s1.resize(3);			//CSDstring s2("CSDN!!!!!");	//CSDN!!!!!s2.resize(20, '*');		//CSDN!!!!!***********

若给出的n大于对象当前的capacity，则capacity也会根据自己的增长规则进行扩大。

使用reserve改变当前对象的容量大小

void reserve (size_t n = 0);

当n大于对象当前的capacity时，将capacity扩大到n或大于n。

当n小于对象当前的capacity时，什么也不做。

eg:

	string s1("Hello");cout << s1.size() << ' ' << s1.capacity() << endl;//5 15s1.reserve(20);cout << s1.size() << ' ' << s1.capacity() << endl;//5 31s1.reserve(2);cout << s1.size() << ' ' << s1.capacity() << endl;//5 31

此函数对字符串的size没有影响，并且无法更改其内容 

使用clear删除对象的内容，删除后对象变为空字符串

void clear();

eg:

    string s1("Hello World");cout << s1 << endl;		//Hello Worlds1.clear();cout << s1 << endl;		//空

使用empty判断对象是否为空

bool empty() const;

若为空，返回1；

不为空，返回0。 

eg:

	string s("CSDN");cout << s.empty() << endl; //0//clear()删除对象的内容，该对象将变为空字符串s.clear();cout << s.empty() << endl; //1

string中元素的访问

[ ]+下标

因为string类对[ ]运算符进行了重载，所以我们可以直接使用[ ]+下标访问对象中的元素。并且该重载使用的是引用返回，所以我们可以通过[ ]+下标修改对应位置的元素。

 char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;

eg:

	string s1("Hello CSDN");for (int i = 0; i < s1.size(); i++){cout << s1[i] << " ";}cout << endl;//H e l l o   C S D N//通过下标+[]来改变值for (int i = 0; i < s1.size(); i++){s1[i]++;`在这里插入代码片`}for (auto e : s1){cout << e << " ";}//I f m m p ! D T E O

使用at访问对象中的元素

因为at函数也是使用的引用返回，所以我们也可以通过at函数修改对应位置的元素

  	char& at (size_t pos);const char& at (size_t pos) const;

eg:

	string s("CSDN");for (size_t i = 0; i < s.size(); i++){//at(pos)访问pos位置的元素cout << s.at(i);}cout << endl;for (size_t i = 0; i < s.size(); i++){//at(pos)访问pos位置的元素，并对其进行修改s.at(i) = 'x';}cout << s << endl; //xxxx

使用范围for访问对象中的元素

！！！若是需要通过范围for修改对象的元素，则用于接收元素的变量e的类型必须是引用类型，否则e只是对象元素的拷贝，对e的修改不会影响到对象的元素。 

    string s("CSDN");//使用范围for访问对象元素for (auto e : s){cout << e;}cout << endl; //CSDN//使用范围for访问对象元素，并对其进行修改for (auto& e : s) //需要修改对象的元素，e必须是引用类型{e = 'x';}cout << s << endl; //xxxxreturn 0;

使用迭代器访问对象中的元素

    //使用迭代器访问对象元素string s1("Hello csdn");for (auto it = s1.begin(); it != s1.end(); it++){*it = toupper(*it);}cout << s1;		//HELLO CSDN

迭代器的实现 

迭代器有普通迭代器以及const修饰的迭代器，所以我们可以实现两种不同的迭代器

其中，const迭代器可读不可写

typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{return _str;
}iterator end()
{return _str + _size;
}const_iterator begin() const
{return _str;
}
const_iterator end() const
{return _str + _size;
}

string中与迭代器相关的函数

与正向迭代器相关的函数

begin函数：返回一个指向字符串第一个字符的迭代器。

	  iterator begin();
const_iterator begin() const;

end函数：返回一个指向字符串结束字符的迭代器，即’\0’

	  iterator end();
const_iterator end() const;

begin，end为左闭右开  [  )

eg:

	//正向迭代器string::iterator it = s.begin();while (it != s.end()){cout << *it;it++;}cout << endl; //hello string

与反向迭代器相关的函数

rbegin函数：返回指向字符串最后一个字符的反向迭代器。

		reverse_iterator rbegin();const_reverse_iterator rbegin() const;

rend函数：返回指向字符串第一个字符前面的理论元素的反向迭代器。

		reverse_iterator rend();const_reverse_iterator rend() const;

eg:

	//反向迭代器string::reverse_iterator rit = s.rbegin();while (rit != s.rend()){cout << *rit;rit++;}cout << endl; //gnirts olleh

string与字符串之间的转换

将字符串转换为string

	1.string s1("hello world");2.char str[] = "hello world";string s2(str);cout << s1 << endl; //hello worldcout << s2 << endl; //hello world

使用c_str或data将string转换为字符串

const char* c_str() const;
const char* data() const;

在C++98中，c_str()返回 const char* 类型，返回的字符串会以空字符结尾。

在C++98中，data()返回 const char* 类型，返回的字符串不以空字符结尾。

 在C++11版本中，c_str()与data()用法相同。

	string s1("Hello World");auto str1 = s1.data();		auto str2 = s1.c_str();cout << str1 << endl;		//Hello Worldcout << str2 << endl;		//Hello World

string中子字符串的提取

使用substr函数提取string中的子字符串

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

eg:

string s1("abcdef");string s2;//substr(pos, n)提取pos位置开始的n个字符序列作为返回值s2 = s1.substr(2, 4);cout << s2 << endl; //cdef

使用copy函数将string的子字符串复制到字符数组中

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

eg:

	string s("abcdef");char str[20];//copy(str, n, pos)复制pos位置开始的n个字符到str字符串size_t length = s.copy(str, 4, 2);//copy函数不会在复制内容的末尾附加'\0'，需要手动加str[length] = '\0'; cout << str << endl; //cdef

getline函数

使用>>进行输入操作时，当>>读取到空格便会停止读取，所以不能用>>将一串含有空格的字符串读入到string对象中。这时，就需要用getline函数完成一串含有空格的字符串的读取操作了。

用法1： getline函数将从is中提取到的字符存储到str中，直到读取到换行符’\n’为止。

istream& getline (istream& is, string& str);

eg:

	string s;getline(cin, s); //输入：hello CSDNcout << s << endl; //输出：hello CSDN

用法2：getline函数将从is中提取到的字符存储到str中，直到读取到delim前一字符为止。

istream& getline (istream& is, string& str, char delim);

eg:

	string s;getline(cin, s, 'D'); //输入：hello CSDNcout << s << endl; //输出：hello CS