本文详细介绍了C++中的string类，包括初始化、操作、比较和处理字符的方法。同时，探讨了vector的基本使用，如初始化、添加元素和其他操作。还提到了迭代器在两者中的应用，以及如何使用STL算法操作string对象。最后，文章对比了数组、vector和指针的区别，并讨论了多维数组的概念。
参考：
- C++_Primer 第五版
- C++ string类（C++字符串）完全攻略
string 支持可变长字符串；vector支持可变长的集合
0. 前言
C++程序中习惯使用 != 而非 < 。同，习惯使用迭代器 而非 下标。
原因在于所有标准库 容器的迭代器都定义了 == 和 ！= , 但是它们之后都没有定于 < 运算符。
1. 标准库类型 string
1.0 头文件
#include<string>
using std::string;
1.1 初始化
- 直接初始化
- 拷贝初始化
注意点：
string 类没有接收一个整型参数或一个字符型参数的构造函数。
下面的两种写法是错误的：
string s1('K'); // 错
string s2(123); // 错
但是，可以用 char* 类型的变量、常量，以及 char 类型的变量、常量对 string 对象进行赋值。
string s1;
s1 = "Hello"; // s1 = "Hello" // 对
s2 = 'K'; // s2 = "K” // 对
1.2 string对象操作
注意点：
-
读写string 对象：
读取时，string对象会自动忽略开头的空白(即 空格符、换行符、制表符等)，
直到遇到下一处空白为止。 -
使用getline替代>>运算符
geline(cin, s)
1.读取一整行
2.在字符串中保留输入时的空白符 -
求字符串的长度
length 成员函数返回字符串的长度。size 成员函数可以实现同样的功能。 -
size函数返回是无符号整型数。
举例：C++错误：s.size()与int混用//若n为负值的 int s,size() < n // 结果肯定是 True // 因为负值n 会自动转成一个比较大的无符号值 -
字符串比较
比较运算符逐一比较 字符串，先比较字符ASCII码, 后比较长度 -
字符串相加
混用string对象与字面值时，必须保证每个(+)号运算符 的两侧对象至少有一个stringstring s ; string s1 = s + "," ; // 正确 string s1 = s + "," + "world"; // 正确 string s1 =(s + ",")+ "world"; // 正确 string s1 = "," + "world" + s; // 错误 string s = "hello" + "," ; // 错误：两边对象都不是string此外，string 类还有 append 成员函数，可以用来向字符串后面添加内容。append 成员函数返回对象自身的引用
string s1("123"), s2("abc"); s1.append(s2); // s1 = "123abc" s1.append(s2, 1, 2); // s1 = "123abcbc" s1.append(3, 'K'); // s1 = "123abcbcKKK" s1.append("ABCDE", 2, 3); // s1 = "123abcbcKKKCDE"，添加 "ABCDE" 的子串(2, 3) -
string对象的比较
除了可以用 <、<=、==、!=、>=、> 运算符比较 string 对象外，string 类还有 compare 成员函数，可用于比较字符串。
compare 成员函数有以下返回值：
小于 0 表示当前的字符串小；
等于 0 表示两个字符串相等；
大于 0 表示另一个字符串小；string s1("hello"), s2("hello, world"); int n = s1.compare(s2); n = s1.compare(1, 2, s2, 0, 3); //比较s1的子串 (1,2) 和s2的子串 (0,3) n = s1.compare(0, 2, s2); // 比较s1的子串 (0,2) 和 s2 n = s1.compare("Hello"); n = s1.compare(1, 2, "Hello"); //比较 s1 的子串(1,2)和"Hello” n = s1.compare(1, 2, "Hello", 1, 2); //比较 s1 的子串(1,2)和 "Hello" 的子串(1,2)
1.3 处理string对象中的字符
-
处理每个字符：for 语句
for( declaration : expression) statement eg. for( auto c : str) cout << c << endl;注意：参考
For(auto x : str) 是利用x生成str中每一个值的复制，对x的赋值不会影响到原容器。
For(auto &x : str) 是利用x生成str中每一个值的引用，对x的操作会影响到原容器。
想要拷贝元素： for(auto x:range)
想要修改元素： for(auto &x:range)
想要只读元素： for(const auto& x:range) -
处理部分字符：（1）下标、（2）迭代器
下标：从0 到 s.size()-1 for( decltype(s.size()) index = 0 ; index != s.size() && !isspace(s[index]) ; ++index ) 设下标类型为 string::size_type 无符号数，可以确保下标不会小于0 -
求 string 对象的子串
substr 成员函数可以用于求子串 (n, m)，原型如下：string substr(int n = 0, int m = string::npos) const;调用时，如果省略 m 或 m 超过了字符串的长度，则求出来的子串就是从下标 n 开始一直到字符串结束的部分。例如：
string s1 = "this is ok"; string s2 = s1.substr(2, 4); // s2 = "is i" s2 = s1.substr(2); // s2 = "is is ok" -
交换两个string对象的内容
swap 成员函数可以交换两个 string 对象的内容。例如：string s1("West”), s2("East"); s1.swap(s2); // s1 = "East"，s2 = "West" -
查找子串和字符
string 类有一些查找子串和字符的成员函数，它们的返回值都是子串或字符在 string 对象字符串中的位置（即下标）。
如果查不到，则返回 string::npos。
string: :npos 是在 string 类中定义的一个静态常量。这些函数如下：
find：从前往后 查找子串或字符出现的位置。
rfind：从后往前 查找子串或字符出现的位置。
find_first_of：从前往后查找何处出现另一个字符串中包含的字符。
**** 例如：s1.find_first_of(“abc”); //查找s1中第一次出现"abc"中任一字符的位置
find_last_of：从后往前查找何处出现另一个字符串中包含的字符。
find_first_not_of：从前往后查找何处出现另一个字符串中没有包含的字符。
find_last_not_of：从后往前查找何处出现另一个字符串中没有包含的字符。 -
替换子串
replace 成员函数可以对 string 对象中的子串进行替换，返回值为对象自身的引用。string s1("Real Steel"); s1.replace(1, 3, "123456", 2, 4); //用 "123456" 的子串(2,4) 替换 s1 的子串(1,3) cout << s1 << endl; //输出 R3456 Steel string s2("Harry Potter"); s2.replace(2, 3, 5, '0'); //用 5 个 '0' 替换子串(2,3) cout << s2 << endl; //输出 HaOOOOO Potter int n = s2.find("OOOOO"); //查找子串 "00000" 的位置，n=2 s2.replace(n, 5, "XXX"); //将子串(n,5)替换为"XXX" cout << s2 < < endl; //输出 HaXXX Potter -
删除子串
erase 成员函数可以删除 string 对象中的子串，返回值为对象自身的引用。string s1("Real Steel"); s1.erase(1, 3); //删除子串(1, 3)，此后 s1 = "R Steel" s1.erase(5); //删除下标5及其后面的所有字符，此后 s1 = "R Ste" -
插入字符串
insert 成员函数可以在 string 对象中插入另一个字符串，返回值为对象自身的引用。string s1("Limitless"), s2("00"); s1.insert(2, "123"); //在下标 2 处插入字符串"123"，s1 = "Li123mitless" s1.insert(3, s2); //在下标 3 处插入 s2 , s1 = "Li10023mitless" s1.insert(3, 5, 'X'); //在下标 3 处插入 5 个 'X'，s1 = "Li1XXXXX0023mitless" -
字符串转换(参考：函数调用中的字符串转换)
stol 字符串转换为long int
long int stol（const string＆str，size_t * idx = 0，int base = 10）stoll 字符串转换为long long int
long long int stoll（const string＆str，size_t * idx = 0，int base = 10）
1.3 将 string 对象作为流处理
使用流对象 istringstream 和 ostringstream，可以将 string 对象当作一个流进行输入输出。使用这两个类需要包含头文件 sstream。
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main()
{
string src("Avatar 123 5.2 Titanic K");
istringstream istrStream(src); //建立src到istrStream的联系
string s1, s2;
int n; double d; char c;
istrStream >> s1 >> n >> d >> s2 >> c; //把src的内容当做输入流进行读取
ostringstream ostrStream;
ostrStream << s1 << endl << s2 << endl << n << endl << d << endl << c <<endl;
cout << ostrStream.str();
return 0;
}
程序的输出结果是：
Avatar
Titanic
123
5.2
K
- 第 11 行，从输入流 istrStream 进行读取，过程和从 cin 读取一样，只不过输入的来源由键盘变成 string 对象src。
因此，“Avatar” 被读取到 s1，123 被读取到 n，5.2 被读取到 d，“Titanic” 被读取到s2，‘K’
被读取到 c。 - 第 12 行，将变量的值输出到流 ostrStream。输出结果不会出现在屏幕上，而是被保存在 ostrStream 对象管理的某处。
用ostringstream 类的 str 成员函数能将输出到 ostringstream 对象中的内容提取出来。
1.4 用 STL 算法操作 string 对象
string 对象也可以看作一个顺序容器，它支持随机访问迭代器，也有 begin 和 end 等成员函数。
STL 中的许多算法也适用于 string 对象。
下面是用 STL 算法操作 string 对象的程序示例。（参考）
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
string s("afgcbed");
string::iterator p = find(s.begin(), s.end(), 'c');
if (p!= s.end())
cout << p - s.begin() << endl; //输出 3
sort(s.begin(), s.end());
cout << s << endl; //输出 abcdefg
next_permutation(s.begin(), s.end());
cout << s << endl; //输出 abcdegf
return 0;
}
2. 标准库类型vector
2.0 头文件
#include<vector>
using std::vector;
2.1 初始化
2.2 向vector对象中添加元素
vector<int> v;
for(int i = 0 ; i !=100; i++ ){
v.push_back(i);
}
2.3 其他vector操作
注意：
- 不能使用下标形式 添加元素，下标可以用来访问已存在的元素
3. 迭代器
3.1 begin & end
auto a = v.begin(); // 第一个元素的迭代器
auto b = v.end(); // 尾元素的下一个位置
// 若容器为空，则 begin 和 end 返回的是同一个迭代器，都是尾后迭代器
// begin 和 end 返回类型由对象决定。
vector<int>::iterator it; // it 能 读 & 写 元素
vector<int>::const_iterator it; // it 能 读 但不能 写 元素
auto it1 = v.cbegin(); // it1类型是vector<int>::const_iterator
auto it1 = v.cend();
3.2 迭代器运算符
3.3 迭代器解引用 与 成员访问
解引用迭代器 可获得迭代器所指的对象。
箭头运算符：
把解引用 和 成员访问 两个操作结合一起。
it -> men 意思等于 (*it).men
3.4 迭代器运算
4. 数组
4.0 对比vector
数组大小确定固定，不能随意向数组中增加元素。
不清楚元素的确切个数时，使用vector。
- 不允许使用数组赋值另一个数组
- 不允许使用vector对象初始化数组
- 允许 使用数组来初始化vector
int int_arr[ ] = {0,1,2,3,4,5}; vector<int> ivec ( begin(int_arr), end(int_arr) );
4.1 初始化数组
注意点：
- 字符数组：空字符也会像字符串其他字符一样被拷贝到字符数组中。
char a1[ ] = {'A', '+', 'B'}; // 列表初始化，没有空字符 char a1[ ] = {'A', '+', 'B', '\0'}; // 列表初始化，含有显式的空字符 const char a [ 6 ] = "Daniel"; // 错误：没有空间可存放空字符 - 不允许拷贝和赋值
int a[ ] = {0,1,2}; int a1[ ] = a; // 错误 a2 = a; // 错误 - 不存在引用 的数组
对数组而言，由内向外的顺序理解。
*Parray 意味着是指针，所以Parray是指向大小为10的数组的指针。
int 意味着数组中的元素为int 类型。
&arrRef 意味着表示一个引用，引用的对象是一个大小为10的数组，数组中的类型为 int。
4.2 指针与数组
string nums[]={"one","two","three"};
string *p = &nums[0];
string *p = nums;
//两者相同
4.3 “数组指针”和“指针数组”
本质：优先级 “()”的优先级比“[]”高， []”的优先级要比“*”要高 。 ( ) > [ ] > ∗ ()>[]>* ()>[]>∗
-
数组指针（也称行指针）
1.数组指针可以说成是”数组的指针”。首先这个变量是一个指针，其次，”数组”修饰这个指针，
意思是说这个指针存放着一个数组的首地址，或者说这个指针指向一个数组的首地址。
“()” 的优先级比“[]”高，“ ∗ * ∗”号和 p 构成一个指针的定义，指针变量名为 p。int 修饰的是数组的内容，即数组的每个元素。
2.数组指针也称指向一维数组的指针，亦称行指针。int a[3][4]; int (*p)[4]; //该语句是定义一个数组指针，指向含 4 个元素的一维数组。 p=a; //将该二维数组的首地址赋给 p，也就是 a[0]或 &a[0][0] p++; //该语句执行过后，也就是 p=p+1; p 跨过行 a[0][]指向了行 a[1][] int(*p2)[5] // 可以理解为 int [5] (*p2) // p2 是一个指针，它指向一个包含 5 个 int 类型数据的数组
-
指针数组
首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身的大小决定，每一个元素都是一个指针。
i n t ∗ p [ n ] ; int *p[n]; int∗p[n];
[]优先级高，先与 p 结合成为一个数组，再由 int*说明这是一个整型指针数组，它有 n 个指针类型的数组元素。int *p[3]; int a[3][4]; p++; //该语句表示 p 数组指向下一个数组元素。注：此数组每一个元素都是一个指针 for(i=0;i<3;i++) p[i]=a[i] 这里 int *p[3] 表示一个一维数组内存放着三个指针变量，分别是 p[0]、p[1]、p[2]，所以要分别赋值。
-
对比
int arr[5]={1，2，3，4，5}; int *p[5]; // 指针数组 p[0] = &arr[0]; // (int *)( p[5] ) int (*p)[5]; // 数组指针 p = &arr; int (*p1)[5] = &arr; /*下面是错误的*/ int (*p2)[5] = arr; -
指针数组:
指针数组常用在主函数传参，在写主函数时，参数有两个
一个确定参数个数，一个这是指针数组用来接收每个参数（字符串）的地址int main(int argc, char *argv[])内存映像图中，主函数的栈区有一个叫argv的数组，这个数组的元素是你输入的参数的地址，指向着只读数据区。
如果是向子函数传参，这和传递一个普通数组的思想一样，不能传递整个数组过去，如果数组很大，这样内存利用率很低，所以应该传递数组的首地址，用一个指针接收这个地址。因此，指针数组对应着二级指针
void fun(char **pp); //子函数中的形参 fun(char *p[]); //主函数中的实参 -
数组指针
数组指针既然是一个指针，那么就是用来接收地址，在传参时就接收数组的地址，所以数组指针对应的是二维数组。void fun( int (*P)[4] ); //子函数中的形参 a[3][4] = {0}; //主函数中定义的二维数组 fun(a); //主函数调用子函数的实参，是二维数组的首元素首地址
4.4 指针与迭代器
int ia[ ] = {0,1,2,3,4,5,6,7,8,9};
int *beg = begin(ia); // 指向ia 首元素的指针
int *last = end(ia); // 指向ia 尾元素的下一位置的指针。
auto n = end(ia) - begin(ia); // 计算数组中的元素的数量
4.5 多维数组
多维数组 就是 数组的数组。
5 C标准库string 函数
注意点：
- 传入此类函数的指针必须指向以空字符作为结束的数组
扫一扫
736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
