C++入门之数组的概念

背景

上一篇文章我们介绍了C++中的迭代器，这篇文章将会介绍C++中数组的概念，数组是一种和vector类似的数据结构，但是其在性能和灵活性上的权衡中选择了性能而放弃了一定的灵活性，其与vector相同的地方是，它们都是同一类型的对象的容器，也都可以通过下标访问。其不同点是数组的大小是固定的，所以无法向一个数组添加元素，也正是因为其大小固定，所以其在运行时有更好的性能。

定义和初始化数组

数组是一个复合类型，可以通过类似a[d]的形式定义，其中a是数组名，d是数组的容量，d必须要大于0，数组的容量是数组类型的一部分，其导致数组容量必须要在编译时就已知，这要求数组容量必须是常量表达式，以下提供了数组声明的几种形式：

unsigned cnt = 42; //不是一个常量表达式
constexpr unsigned sz = 42; //是常量表达式

int arr[10]; //声明一个容量为10的整型数组
int *parr[sz]; //42个指向整形指针的数组
string bad[cnt]; //这是个错误声明，因为cnt不是常量表达式

默认情况下，数组里面的元素都会被默认初始化。

我们可以通过列表初始化一个数组，通过这种方式我们在定义时可以忽略数组的容量，如果我们指定了数组容量，那么在列表初始化时初始化的元素数量不能超过设置的容量值，如果少于设置的数组的数量，没有指定值的元素会使用默认初始化的值，例子如下：

const unsigned sz = 3;
int a1[sz] = {0, 1, 2};
int a2[] = {0, 1, 2}; //可以忽略数组的容量
int a3[5] = {0, 1, 2}; //等价于{0, 1, 2, 0, 0}
string a4[3] = {"hi", "bye"}; //等价于{"hi", "bye", ""}
int a5[2] = {0, 1, 2}; //错误

字符数组的定义

字符数组有一个额外的初始化方式，就是可以通过一个字符还去初始化字符数组，但是需要注意的是string是以null字符结尾的，所以在定义数组容量时要考虑null字符：

char a1[] = "C++"; //其等价于{'C', '+', '+', '\\0'}
char a2[6] = "Daniel" //错误，其未考虑到null字符

❝需要注意的是一些编译器是不支持数组的拷贝，如果直接通过一个数组去初始化另一个数组可能会报错

❞

理解复杂的数组声明

正如vector，array也可以容纳所有的类型，例如指针的数组，由于数组是一个对象，所以可以定义指向数组的指针和引用，，定义指向数组的指针或者引用可以通过以下方式：

int *ptre[10]; //ptre是一个数组，其中的元素是10个指向整型的指针
int (*parray)[10] = &arr; //parray是一个指针，其指向的对象是一个容量为10的整型数组
int (&arrRef)[10] = arr; //arrRef是一个引用，其指向的是一个容量为10的整型数组

❝在理解声明时可以按照从左到右，从内到外的顺序。

❞

指针与数组

在C++中指针和数组关系是很近的，一般来说，当我们使用一个数组，编译器会自动将其转化为一个指针，一般来说我们是通过地址操作符来获取一个对象的指针的，但是对于数组而言，当我们使用数组时，编译器将会自动获取一个指针指向数组的第一个元素：

string nums = {"one", "two", three}; 
string *p = &nums[0]; //p指向nums的第一个元素
string *p2 = nums //等价于string *p = &nums[0];

❝在大多数表达式中，我们使用数组对象，我们其实是获取一个指针指向数组的第一个元素

❞

由于这个影响，我们对于数组的操作其实绝大多数都是对于指针的操作，其中一个比较明显的是当我们使用auto和数组去初始化一个变量时，其实是声明了一个指针而不是数组：

int ia[] = {0, 1, 2, 3, 4};
auto ia2(ia); //ia2是一个整形指针，指向ia的第一个元素
ia2 = 43 //错误，不可以将int赋值给一个指针
auto ia3(&ia[0]) //这样看起来更清楚，ia3是整型指针

需要注意的是当我们使用之前提到的decltype时不会发生这种转化, decltype(ia)返回的类型是10个整型的数组：

decltype(ia) ia3 = {0, 1, 2, 3, 4};
ia3 = p; // 错误，不可以将一个整型指针赋值给一个数组
ia3[4] = i; //正确，可以对数组的元素赋值

指针是迭代器

指针也是迭代器，指向数组元素的指针同样支持我们之前提到的vector和string中迭代器的操作，例如可以通过自增操作实现从一个元素移动到下一个元素：

int arr[] = [0, 1, 2, 3, 4, 5];
int *p = arr; //现在p指向arr[0]
++p; //现在p指向arr[1]

正如我们可以使用迭代器遍历vector中的元素，我们也可以使用指针去遍历数组中的元素，我们可以通过上面的方式获取数组的第一个元素的指针，那么我们又该如何获取数组最后一个元素之后的不存在的元素呢，我们可以通过以下方式：

int *e = &arr[6];

我们只可以获取最后一个元素的下一个元素的地址

for (int *b = arr; b != e; ++b)
    cout<< *b<

虽然我们可以通过上述方式获取数组的第一个元素的地址和最后一个元素的下一个地址，但是这并不是一个好的方法，在新的规范中已经提供了新的函数begin和end可以获取数组的第一个元素的地址和最后一个元素的下一个地址：

int ia[] = {0, 1, 2, 3, 4};
int *beg = begin(ia);
int *last = end(ia);

指针的算术运算

指向数组元素的指针可以使用我们之前在迭代器的文章中提到的所有的迭代器的操作，当我们使用指针加上或者减去一个整型的值时我们将会获得一个新的指针，这个指针指向原来数组元素前或者后几个位置的元素，具体的位置取决于加或者减的值:

constexpr size_t sz = 5;
int arr[sz] = {1, 2, 3, 4, 5};
int *p1 = arr; //等价于*p1 = &arr[0]
int *p2 = p1 + 4; //p2指向arr[4]

当我们用数组加上sz时，编译器会把arr转化为指向数组第一个元素的指针，所以如下p就是指向数组最后一个元素的下一个元素，如果相加结果超出数组的范围则会发生错误：

int *p = arr + sz; //小心使用，没有解引用
int *p3 = arr + 10; //错误，数组只有5个元素，虽然编译器可能无法检测到这个错误

和迭代器一样，两个指针相减其结果是两个指针之间的距离，其前提是这两个指针式同一个数组中的元素：

auto n = end(arr) - begin(arr);

解引用和指针的算术运算

通过上面的介绍我们已经知道了指针也有算数运算，那么如何判断是指针的算术运算还是元素的算术运算呢，可以和之前复杂的指针对应，都是先从括号内部开始：

int ia = {0, 2, 4, 6, 8};
int last = *(ia + 4); //先看括号内，所以这是指针的元素暗，last = ia[4] = 8
int last2 = *ia + 4; //ia指向ia[0], 所以last2 = ia[0] + 4 = 4

下标与指针

我们可以看到数组其实就是一个指向数组第一个元素的指针，所以对于数组的下标操作其实就是对于指针的算数元运算,ia[2]等价于*(ia + 2):

int ia = {0, 2, 4, 6, 8};
int *p = &ia[2]; //p指向ia[2]的指针
int j = p[-2]; p[-2]等价于*(p - 2), 所以j = ia[0]