# 字符串、向量和数组

# 命名空间的 using 声明

我们使用的库函数都有一个对应的命名空间，通常需要在声明或初始化变量时指定命名空间。为了简化这个操作，我们可以使用using进行声明：

1
2
3

using std::cout;  // 单独使用某个函数

using namespace std;  // 批量声明 std 中所有函数

头文件中不应该包含 using 声明，这样使用了该头文件的源文件也会使用这个声明，会带来风险。

# 标准库类型 string

标准库类型 string 表示可变长的字符序列，使用 string 类型必须首先包含 string 头文件：

1
2
3

#include <string>

using std::string

# 定义和初始化 string 对象

初始化 string 对象的方式：

拷贝初始化（copy initialization）：使用 = 将一个已有的对象拷贝到正在创建的对象。

直接初始化（direct initialization）：通过括号给对象赋值。

# string 对象的操作

string的操作：

读取 string 对象：

• 使用 IO 操作符 >> 读取：忽略开头的空白（空格符、换行符、制表符等），从第一个真正的字符开始读起，直到遇到下一个空白。
• 使用 getline() 函数读取：将一整行读取为 string 对象，包括空白。

s.size() 返回 string::size_type 类型，是 无符号 类型的值，不能和 int 混用。

s1 + s2 使用时，必须保证至少其中一个为 string 类型。例如：string s = "hello" + "world" 错误，其 + 两边都为字符串字面值。

字符串字面值 和 string 是不同的类型。

# 处理 string 对象中的字符

C++ 修改了 c 的标准库 ctype.h 为 cctype，其中定义了一组标准函数：

遍历字符串：

1
2
3

for (auto c : str) {
    ...
}

str[idx] 中的 idx 为 string::size_type 类型，如果使用 int 会隐式转换为该类型。

# 标准库类型 vector

标准库类型 vector 表示对象的集合，其中给所有对象的类型都相同。因为 vector 容纳着其他对象，所以称其为 容器（container），使用 vector 必须包含其头文件：

1
2
3

#include <vector>

using std::vector

vector 同时也是 类模板（class template），模板本身不是类或函数，但可以使用模板创建类，这个过程称为 实例化（instantiation）。

当使用模板时，需要指出编译器应把类或函数实例化成何种类型：

1
2

vector<int> ls;  // ls 保存 int 类型的对象
vector<vector<string>> files;  // 该向量中的元素是 vector 对象

vector 是模板，vector<int> 是类型。

# 定义和初始化 vector 对象

初始化vector对象的方法：

# vector 对象的操作：

vector支持的操作：

# 迭代器介绍

除了下标运算符外，迭代器（iterator） 也可以访问对象中的元素，所有标准库的容器都支持迭代器。类似于指针类型，迭代器也提供了对对象的间接访问。

# 使用迭代器

拥有迭代器的类型都具有 begin 和 end 成员，其中 begin 成员返回指向第一个元素的迭代器：

1
2

vector<int> ls{1, 2, 3};
auto b = v.begin(), e = v.end();  // b 和 e 类型相同

end 成员返回指向容器“尾元素的下一个位置（one past the end）”的迭代器，即 end 指向容器的 尾后（off the end） 元素。这样的迭代器通常没有意义，只是作为标记，被称为 尾后迭代器（off-the-end iterator） 或 尾迭代器（end iterator）。

若容器为空，则 begin 和 end 都返回尾后迭代器。

标准容器迭代器的运算符:

泛型编程：尽量使用 != 来对迭代器进行判断

迭代器也拥有自己的类型：

1
2

vector<int>::iterator it;  // it 是 vector<int> 类型的迭代器，可以读写元素
vector<int>::const_iterator it2;  // it2 只能读，不能写

如果容器中的值为常量，则 begin 和 end 返回 const_iterator，否则返回 iterator。

解引用和成员访问：解引用迭代器可以获得迭代器所指的对象，如果该对象是一个类，则可以进一步访问其成员：

1
2
3
4
5
6

vector<string> ls{"str1", "str2"};

auto it = ls.begin();
string s = *it;  // s 为 "str1"
bool flag = (*it).empty();  // 解引用访问 string 成员
bool flag = it->empty();  // 作用同上

# 迭代器运算

string 和 vector 的迭代器提供了额外的运算符，支持迭代器的关系运算和跨过多个元素，这些运算称为 迭代器运算（iterator arithmetic）：

当两个迭代器指向同一个容器时，它们可以进行加减操作得到距离，这个距离的类型为 difference_type 类型，是带符号整数型。

# 数组

数组可以看做 vector 的低配版，其 长度固定。

# 定义和初始化内置数组

数组的声明和定义形如 a[d]，其中 a 是数组的名字，d 是数组的维度（大于 0）：

1
2
3
4
5
6
7
8

int cnt = 42;  // 非常量
const int cnt2 = 42;  // 常量

int arr[10]; // 含有 10 个整数的数组
int *arr2[10];  // 含有 10 个整型指针的数组
int arr3[cnt];  // 报错，cnt 非常量
int arr4[cnt2];  // 含有 42 和整数的数组
int arr5[] = {1, 2, 3};  // 自动计算长度的数组

字符数组具有一定特殊性，使用字符串初始化字符数组时在结尾处必须增加一个空字符：

1
2

char arr[] = "hello";
char arr2[5] = "hello";  // 报错，长度不够

不能将数组的内容拷贝给其他数组作为其初始值，也不能用数组为其他数组赋值：

1
2
3

int a[] = {1, 2, 3};
int a2[] = a;  // 报错，不能用数组来初始化数组
a2 = a;  // 报错，不能用数组进行赋值

# 访问数组元素

数组的下标为 size_t 类型，是一种机器相关的无符号类型，它被设计得足够大以便能够表示内存中任意对象的大小。

下标存在越界导致缓冲区溢出等情况，这种情况需要程序员自行检查。

# 指针和数组

使用数组时，编译器会将其转换成指针。使用取地址符可以获取数组的元素的指针，如果是取数组的指针，则默认返回数组第一个元素的指针：

1
2
3

int ls[] = {1, 2, 3}
int *p = &ls[0];  // 数组的元素的指针
int *p2 = ls;  // 等价于 *p2 = &ls[0]

# C 风格字符串

字符串字面值是一种通用结构的实例，这种结构是 C++ 由 C 继承而来的 C 风格字符串（C-style character string） 。 按此习惯书写的字符串存放在字符数组中并以 空字符结束（null terminated）。

在 C++ 程序中尽量不要使用 C 风格字符串，容易引起安全漏洞且不方便。

C标准库String函数，定义在<cstring> 中：

# 多维数组

严格来说，C++ 语言中没有多维数组，所谓的多维数组实际是数组的数组。

1

int arr[10][20] = {0};  // 长度为 10 的数组，其中每个元素是长度为 20 的数组，且都初始化为 0

# 使用范围 for 语句处理多维数组

1
2
3
4
5
6
7

size_t cnt = 0;

for (auto &row: arr) {
    for (auto &col: row) {
        col = cnt; cnt ++;
    }
}