C/C++总述：Study C/C++-CSDN博客
目录
使用max_size函数获取string对象对多可包含的字符数
[[ ]+下标](#[ ]+下标)
标准库类型 string 表示可变长的字符序列，使用 string 类型必须首先包含 string 头文件。作为标准库的一部分，string 定义在命名空间 std 中。
cpp
#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; |
|---|
cpp
/*复制赋值操作符 (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进行尾插
cpp
void push_back (char c);eg:
cpp
int main()
{
string s1;
s1.push_back('C');
s1.push_back('S');
s1.push_back('D');
s1.push_back('N');
return 0;
}
使用insert插入
cpp
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的位置上插入字符ceg:
cpp
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("C"); //C
//insert(pos, str)在pos位置插入字符串str
s.insert(1, "S"); //CS
//insert(pos, string)在pos位置插入string对象
string t("D");
s.insert(2, t); //CSD
//insert(pos, char)在pos位置插入字符char
s.insert(s.end(), 'N'); //CSDN
cout << s << endl; //CSDN
return 0;
}
使用append函数完成string的拼接
cpp
string& append (const string& str); //在字符串尾部追加字符串str
string& append (const char* s); //在字符串尾部追加C风格的字符串s
string& append (size_t n, char c); //将字符c重复追加n次到调用该函数的字符串对象的尾部。eg:
cpp
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进行尾删
cpp
void pop_back();eg:
cpp
int main()
{
string s1("Hello World");
s1.pop_back();
//Hello World
s1.pop_back();
//Hello Worl
s1.pop_back();
//Hello Wor
return 0;
}
使用erase删除
cpp
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:
cpp
int main()
{
string s1("Hello World");
//Hello World
s1.erase(6, 3); //erase(pos, n)删除pos位置开始的n个字符
//Hello ld
s1.erase(s1.end() - 2); //erase(pos)删除pos位置的字符
//Hello d
s1.erase(s1.begin() + 1, s1.begin() + 3); //erase(pos1, pos2)删除[pos1,pos2)上所有字符
//Hlo d
return 0;
}
string的查
使用find函数正向搜索第一个匹配项
cpp
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:
cpp
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函数反向搜索第一个匹配项
cpp
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:
cpp
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函数完成比较
cpp
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:
cpp
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; //0string的改
使用replace函数完成string的替换
cpp
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:
cpp
string s("hello world");
//replace(pos, len, str)将pos位置开始的len个字符替换为字符串str
s.replace(0, 4, "HELLO");
//HELLOo world
//replace(pos, len, n, char)将pos位置开始的len个字符替换为n个字符char
s.replace(10, 3, 3, '!');
//HELLOo wor!!!
使用swap函数完成两个string类的交换
cpp
void swap (string& x, string& y);
void swap (string& str);eg:
cpp
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函数获取当前有效字符的个数
cpp
size_t size() const;
size_t length() const;eg:
cpp
string s1("Hello");
string s2("World");
auto size = s1.size(); //5
auto length = s2.length(); //5使用max_size函数获取string对象对多可包含的字符数
cpp
size_t max_size() const;eg:
cpp
int main()
{
string s("GH");
cout << s.max_size() << endl; //9223372036854775807
return 0;
}使用capacity函数获取当前对象所分配的存储空间的大小
cpp
size_t capacity() const;eg:
cpp
string s1("Hello World");
cout << s1.capacity() << endl; //15使用resize改变当前对象的有效字符的个数
cpp
void resize (size_t n);
void resize (size_t n, char c);当n大于size时，若给出字符c，则用c来填充，否则用'\0'来填充.
当n小于size时，则将size缩小到n
eg:
cpp
string s1("CSDN");
s1.resize(6, '!'); //CSDN!!
s1.resize(3); //CSD
string s2("CSDN!!!!!"); //CSDN!!!!!
s2.resize(20, '*'); //CSDN!!!!!***********
若给出的n大于对象当前的capacity，则capacity也会根据自己的增长规则进行扩大。
使用reserve改变当前对象的容量大小
cpp
void reserve (size_t n = 0);当n大于对象当前的capacity时，将capacity扩大到n或大于n。
当n小于对象当前的capacity时，什么也不做。
eg:
cpp
string s1("Hello");
cout << s1.size() << ' ' << s1.capacity() << endl;
//5 15
s1.reserve(20);
cout << s1.size() << ' ' << s1.capacity() << endl;
//5 31
s1.reserve(2);
cout << s1.size() << ' ' << s1.capacity() << endl;
//5 31此函数对字符串的size没有影响，并且无法更改其内容
使用clear删除对象的内容，删除后对象变为空字符串
cpp
void clear();eg:
cpp
string s1("Hello World");
cout << s1 << endl; //Hello World
s1.clear();
cout << s1 << endl; //空使用empty判断对象是否为空
cpp
bool empty() const;若为空，返回1；
不为空，返回0。
eg:
cpp
string s("CSDN");
cout << s.empty() << endl; //0
//clear()删除对象的内容，该对象将变为空字符串
s.clear();
cout << s.empty() << endl; //1string中元素的访问
[ ]+下标
因为string类对[ ]运算符进行了重载，所以我们可以直接使用[ ]+下标访问对象中的元素。并且该重载使用的是引用返回，所以我们可以通过[ ]+下标修改对应位置的元素。
cpp
char& operator[] (size_t pos);
const char& operator[] (size_t pos) const;eg:
cpp
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函数修改对应位置的元素
cpp
char& at (size_t pos);
const char& at (size_t pos) const;eg:
cpp
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的修改不会影响到对象的元素。
cpp
string s("CSDN");
//使用范围for访问对象元素
for (auto e : s)
{
cout << e;
}
cout << endl; //CSDN
//使用范围for访问对象元素，并对其进行修改
for (auto& e : s) //需要修改对象的元素，e必须是引用类型
{
e = 'x';
}
cout << s << endl; //xxxx
return 0;使用迭代器访问对象中的元素
cpp
//使用迭代器访问对象元素
string s1("Hello csdn");
for (auto it = s1.begin(); it != s1.end(); it++)
{
*it = toupper(*it);
}
cout << s1; //HELLO CSDN迭代器的实现
迭代器有普通迭代器以及const修饰的迭代器，所以我们可以实现两种不同的迭代器
其中，const迭代器可读不可写
cpp
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函数：返回一个指向字符串第一个字符的迭代器。
cpp
iterator begin();
const_iterator begin() const;end函数：返回一个指向字符串结束字符的迭代器，即'\0'
cpp
iterator end();
const_iterator end() const;begin，end为左闭右开 [ )
eg:
cpp
//正向迭代器
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it;
it++;
}
cout << endl; //hello string与反向迭代器相关的函数
rbegin函数：返回指向字符串最后一个字符的反向迭代器。
cpp
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;rend函数：返回指向字符串第一个字符前面的理论元素的反向迭代器。
cpp
reverse_iterator rend();
const_reverse_iterator rend() const;eg:
cpp
//反向迭代器
string::reverse_iterator rit = s.rbegin();
while (rit != s.rend())
{
cout << *rit;
rit++;
}
cout << endl; //gnirts ollehstring与字符串之间的转换
将字符串转换为string
cpp
1.
string s1("hello world");
2.
char str[] = "hello world";
string s2(str);
cout << s1 << endl; //hello world
cout << s2 << endl; //hello world使用c_str或data将string转换为字符串
cpp
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()用法相同。
cpp
string s1("Hello World");
auto str1 = s1.data();
auto str2 = s1.c_str();
cout << str1 << endl; //Hello World
cout << str2 << endl; //Hello Worldstring中子字符串的提取
使用substr函数提取string中的子字符串
cpp
string substr (size_t pos = 0, size_t len = npos) const;eg:
cpp
string s1("abcdef");
string s2;
//substr(pos, n)提取pos位置开始的n个字符序列作为返回值
s2 = s1.substr(2, 4);
cout << s2 << endl; //cdef使用copy函数将string的子字符串复制到字符数组中
cpp
size_t copy (char* s, size_t len, size_t pos = 0) const;eg:
cpp
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; //cdefgetline函数
使用>>进行输入操作时，当>>读取到空格便会停止读取，所以不能用>>将一串含有空格的字符串读入到string对象中。这时，就需要用getline函数完成一串含有空格的字符串的读取操作了。
用法1： getline函数将从is中提取到的字符存储到str中，直到读取到换行符'\n'为止。
cpp
istream& getline (istream& is, string& str);eg:
cpp
string s;
getline(cin, s); //输入：hello CSDN
cout << s << endl; //输出：hello CSDN用法2：getline函数将从is中提取到的字符存储到str中，直到读取到delim前一字符为止。
cpp
istream& getline (istream& is, string& str, char delim);eg:
cpp
string s;
getline(cin, s, 'D'); //输入：hello CSDN
cout << s << endl; //输出：hello CS