cen's blog
cen
2024-10-17
目录

string

# string 构造函数

string();  //构造一个空字符串
string(const char* s);  //复制s所指的字符序列
string(const char* s, size_t n);  //复制s所指字符序列的前n个字符
string(size_t n, char c);  //生成n个c字符的字符串
string(const string& str);  //生成str的复制品
string(const string& str, size_t pos, size_t len = npos);  //复制str中从字符位置pos开始并跨越len个字符的部分
1
2
3
4
5
6

示例：

string s1;                     //构造空字符串
string s2("hello string");     //复制"hello string"
string s3("hello string", 3);  //复制"hello string"的前3个字符
string s4(10, 's');            //生成10个's'字符的字符串
string s5(s2);                 //生成s2的复制品
string s6(s2, 0, 4);           //复制s2中从字符位置0开始并跨越4个字符的部分
1
2
3
4
5
6

# string 插入元素

# push_back

void push_back (char c);  //尾插元素
1

# insert

string& insert (size_t pos, const string& str);
string& insert (size_t pos, const char* s);
iterator insert (iterator p, char c);
1
2
3

示例：

void test06() {
    string s("cen's ");
    s.insert(6,"blo");
    s.insert(s.end(),'g');
    cout << s;  // cen's blog
}
1
2
3
4
5
6

# string 拼接元素

# append

string& append (const string& str);
string& append (const char* s);
string& append (size_t n, char c);
1
2
3

示例：

int main() {
    string s("cen");
    s.append("'s ");
    s.append(3,'q');
    cout << s;
    return 0;
}
1
2
3
4
5
6
7

# operator+=

string& operator+= (const string& str);
string& operator+= (const char* s);
string& operator+= (char c);
1
2
3

示例：

int main() {
    string s("cen");
    s += "'s ";
    s += "blog";
    cout << s;
    return 0;
}
1
2
3
4
5
6
7

# string 删除元素

# pop_back

void pop_back();
1

# erase

string& erase (size_t pos = 0, size_t len = npos);  //删除从pos开始的len个元素
iterator erase (iterator p);  //删除迭代器为pd的元素
iterator erase (iterator first, iterator last); //删除从first到last的所有元素，注意：[ first，last )
1
2
3

示例：

int main() {
    string str = "oishbnsv;lkbds";
    str.erase(str.begin() + 3);
    str.erase(6,4);
    cout << str;    // oisbnsbds
    return 0;
}
1
2
3
4
5
6
7

# string 查找元素

# find 和 rfind

  • 使用 find 函数正向搜索第一个匹配项
size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* s, size_t pos = 0) const;
size_t find (char c, size_t pos = 0) const;
1
2
3

示例：

int main() {
    string s = "abcdegfg";
    cout << s.find('g');    // 5
    cout << s.find("cd");   // 2
    return 0;
}
1
2
3
4
5
6
  • 使用 rfind 函数反向搜索第一个匹配项
int main() {
    string s = "abcdegfg";
    cout << s.rfind('g');    // 7
    cout << s.rfind("cd");   // 2
    return 0;
}
1
2
3
4
5
6

# string 的比较

compare 函数：

int compare (const string& str) const;
int compare (size_t pos, size_t len, const string& str) const;
int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
1
2
3

比较规则：

  1. 比较字符串中第一个不匹配的字符值较小，或者所有比较字符都匹配，但比较字符串较短，则返回小于 0 的值。
  2. 比较字符串中第一个不匹配的字符值较大，或者所有比较字符都匹配，但比较字符串较长，则返回大于 0 的值。
  3. 比较的两个字符串相等，则返回 0。
返回值 str1 和 str2 的关系
<0 str1 < str2
=0 str1 = str2
<0 str1 > str2

示例：

int main() {
    string str1("abcd");
    string str2("abde");
    cout << str1.compare(str2); // -1
    return 0;
}
1
2
3
4
5
6

# string 的替换和交换

  • 替换使用 replace 函数
// 将pos位置开始的len个字符替换为字符串s
string& replace (size_t pos, size_t len, const char* s);
// 将pos位置开始的len个字符替换为n个字符c
string& replace (size_t pos, size_t len, size_t n, char c);
1
2
3
4
  • 交换使用 swap 函数
void swap (string& x, string& y);
void swap (string& str);
1
2

# string 的大小和容量

# size

获取 string 的有效字符个数

# capacity

获取当前对象所分配的存储空间的大小

# resize

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

  1. 当 n 大于对象当前的 size 时，将 size 扩大到 n，扩大的字符为 c，若 c 未给出，则默认为’\0’。
  2. 当 n 小于对象当前的 size 时，将 size 缩小到 n。

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

# reserver

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

  1. 当 n 大于对象当前的 capacity 时，将 capacity 扩大到 n 或大于 n。
  2. 当 n 小于对象当前的 capacity 时，什么也不做。

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

# string 的元素遍历

# [] + 下标

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

    for(int i = 0;i < blog.size();i++) {
        cout << blog[i] << " ";
    }
1
2
3

# at + 下标

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

    for(int i = 0;i < blog.size();i++) {
        cout << blog.at(i) << " ";
    }
1
2
3

# 范围 for 循环

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

    string blog("cen");
    for(auto& c : blog) {
        cout << c << " ";
    }
1
2
3
4

# 使用迭代器

  • begin 函数：返回一个指向字符串第一个字符的迭代器
  • end 函数：返回一个指向字符串结束字符的迭代器
  • rbegin 函数：返回指向字符串最后一个字符的反向迭代器
  • rend 函数：返回指向字符串第一个字符前面的理论元素的反向迭代器

笔记

类型 描述 特点
iterator 正向：begin()\end() 可读可写
const_iterator 正向：begin()\end() 可读
reverse_iterator 反向：rbegin()\rend() 可读可写
const_reverse_iterator 反向：rbegin()\rend() 可读

示例：

void fun1() {
    string s("abcdef");
    // string::iterator it = s.begin();
    auto it = s.begin();
    while(it != s.end()) {
        cout << *it << " ";
        it++;
    }
}

void fun2() {
    string s("abcdef");
    // string::reverse_iterator it = s.begin();
    auto it = s.rbegin();
    while(it != s.rend()) {
        cout << *it << " ";
        it++;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# string 的子字符串提取

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

string substr (size_t pos = 0, size_t len = npos) const;
//substr(pos, n)提取pos位置开始的n个字符序列作为返回值
1
2

# string 的 getline 函数

我们知道，使用cin >> 进行输入操作时，当>>读取到空格便会停止读取，基于此，我们将不能用>>将一串含有空格的字符串读入到 string 对象中。

这时，我们就需要用 getline 函数完成一串含有空格的字符串的读取操作了。

场景一：

istream& getline (istream& is, string& str);
1
#include <iostream>
#include <string>
using namespace std;
int main()
{
	string s;
	getline(cin, s); //输入：hello CSDN
	cout << s << endl; //输出：hello CSDN
	return 0;
}
1
2
3
4
5
6
7
8
9
10

场景二：

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

getline 函数将从 is 中提取到的字符存储到 str 中，直到读取到分隔符 delim 或换行符’\n’为止。

#include <iostream>
#include <string>
using namespace std;
int main()
{
	string s;
	getline(cin, s, 'D'); //输入：hello CSDN
	cout << s << endl; //输出：hello CS
	return 0;
}
1
2
3
4
5
6
7
8
9
10
#笔记
上次更新: 2025/11/11, 22:03:54
泛型模板
vector

← vector→

最近更新
01
动态规划
11-08
02
ProtoBuf
09-28
03
Git
09-28
更多文章>
Theme by Vdoing | Copyright © 2024-2025 京ICP备2020044002号-3 京公网安备11010502056119号