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

感谢阅读！

# from cen

#笔记
上次更新: 2024/10/21, 19:08:18
泛型模板
vector

← vector→

最近更新
01
排序
01-22
02
堆
01-17
03
二叉树
01-17
更多文章>
Theme by Vdoing | Copyright © 2024-2025 京ICP备2020044002号-3 京公网安备11010502056119号