第四章 数组和指针 (part1) 数组

概述：

C++ 语言提供了两种类似于 vector 和迭代器类型的低级复合类型——数组和指针。

与 vector 类型相似，数组也可以保存某种类型的一组对象；

而它们的区别在于，数组的长度是固定的。数组一经创建，就不允许添加新的元素。指针则可以像迭代器一样用于遍历和检查数组中的元素。

现代 C++ 程序应尽量使用 vector 和迭代器类型，而避免使用低级的数组和指针。设计良好的程序只有在强调速度时才在类实现的内部使用数组和指针。

数组是 C++ 语言中类似于标准库 vector 类型的内置数据结构。

与 vector 类似，数组也是一种存储单一数据类型对象的容器，其中每个对象都没有单独的名字，而是通过它在数组中的位置对它进行访问。

与 vector 类型相比，数组的显著缺陷在于：

数组的长度是固定的，而且程序员无法知道一个给定数组的长度。

数组没有获取其容量大小的 size 操作，也不提供 push_back 操作在其中自动添加元素。

如果需要更改数组的长度，程序员只能创建一个更大的新数组，然后把原数组的所有元素复制到新数组空间中去。

《注意》：

与使用标准 vector 类型的程序相比，依赖于内置数组的程序更容易出错而且难于调试。

在出现标准库之前，C++ 程序大量使用数组保存一组对象。而现代的 C++ 程序则更多地使用 vector 来取代数组，数组被严格限制于程序内部使用，只有当性能测试表明使用vector 无法达到必要的速度要求时，才使用数组。然而，在将来一段时间之内，原来依赖于数组的程序仍大量存在，因此，C++ 程序员还是必须掌握数组的使用方法。

4.1. 数组

数组是由类型名、标识符和维数组成的复合数据类型，类型名规定了存放在数组中的元素的类型，而维数则指定数组中包含的元素个数。

《Note》：

数组定义中的类型名可以是内置数据类型或类类型；

除引用之外，数组元素的类型还可以是任意的复合类型。

没有所有元素都是引用的数组。

数组的定义和初始化

数组的维数必须用值大于等于1的常量表达式定义。此常量表达式只能包含整型字面值常量、枚举常量或者用常量表达式初始化的整型const 对象。

非 const 变量以及要到运行阶段才知道其值的 const 变量都不能用于定义数组的维数。

数组的维数必须在一对方括号 [] 内指定：

          // both buf_size and max_files are const
          const unsigned buf_size = 512, max_files = 20;
          int staff_size = 27;            // nonconst
          const unsigned sz = get_size();  // const value not known until run time
          char input_buffer[buf_size];     // ok: const variable
          string fileTable[max_files + 1]; // ok: constant expression
          double salaries[staff_size];     // error: non const variable
          int test_scores[get_size()];     // error: non const expression
          int vals[sz];                    // error: size not known until run time

虽然 staff_size 是用字面值常量进行初始化，但 staff_size 本身是一个非const 对象，只有在运行时才能获得它的值，因此，使用该变量来定义数组维数是非法的。而对于 sz，尽管它是一个 const 对象，但它的值要到运行时调用get_size 函数后才知道，因此，它也不能用于定义数组维数。

          max_files + 1

另一方面，由于 max_files 是 const 变量，因此表达式是常量表达式，编译时即可计算出该表达式的值为21。

显式初始化数组元素

在定义数组时，可为其元素提供一组用逗号分隔的初值，这些初值用花括号{}括起来，称为初始化列表：

          const unsigned array_size = 3;
          int ia[array_size] = {0, 1, 2};

如果没有显式提供元素初值，则数组元素会像普通变量一样初始化

• 在函数体外定义的内置数组，其元素均初始化为 0。

• 在函数体内定义的内置数组，其元素无初始化。

• 不管数组在哪里定义，如果其元素为类类型，则自动调用该类的默认构造函数进行初始化；如果该类没有默认构造函数，则必须为该数组的元素提供显式初始化。

<note>:

除非显式地提供元素初值，否则内置类型的局部数组的元素没有初始化。此时，除了给元素赋值外，其他使用这些元素的操作没有定义。

显式初始化的数组不需要指定数组的维数值，编译器会根据列出的元素个数来确定数组的长度：

          int ia[] = {0, 1, 2}; // an array of dimension 3

如果指定了数组维数，那么初始化列表提供的元素个数不能超过维数值。

如果维数大于列出的元素初值个数，则只初始化前面的数组元素；

剩下的其他元素，若是内置类型则初始化为0，若是类类型则调用该类的默认构造函数进行初始化：

          const unsigned array_size = 5;
          // Equivalent to ia = {0, 1, 2, 0, 0}
          // ia[3] and ia[4] default initialized to 0
          int ia[array_size] = {0, 1, 2};
          // Equivalent to str_arr = {"hi", "bye", "", "", ""}
          // str_arr[2] through str_arr[4] default initialized to the empty string
          string str_arr[array_size] = {"hi", "bye"};

特殊的字符数组

字符数组既可以用一组由花括号括起来、逗号隔开的字符字面值进行初始化，也可以用一个字符串字面值进行初始化。

然而，要注意这两种初始化形式并不完全相同，字符串字面值包含一个额外的空字符（null）用于结束字符串。

当使用字符串字面值来初始化创建的新数组时，将在新数组中加入空字符：

          char ca1[] = {'C', '+', '+'};                // no null
          char ca2[] = {'C', '+', '+', '\0'};         // explicit null
          char ca3[] = "C++";     // null terminator added automatically

ca1 的维数是 3，而 ca2 和 ca3 的维数则是 4。使用一组字符字面值初始化字符数组时，一定要记得添加结束字符串的空字符。例如，下面的初始化将导致编译时的错误：

          const char ch3[6] = "Daniel"; // error: Daniel is 7 elements

上述字符串字面值包含了 6 个显式字符，存放该字符串的数组则必须有 7 个元素——6 个用于存储字符字面值，而 1 个用于存放空字符 null。

不允许数组直接复制和赋值

与vector不同，一个数组不能用另外一个数组初始化，也不能将一个数组赋值给另一个数组，这些操作都是非法的：

          int ia[] = {0, 1, 2}; // ok: array of ints
          int ia2[](ia);        // error: cannot initialize one array with another

          int main()
          {
              const unsigned array_size = 3;
              int ia3[array_size]; // ok: but elements are uninitialized!

              ia3 = ia;           //  error: cannot assign one array to another
              return 0;
          }

一些编译器允许将数组赋值作为编译器扩展。但是如果希望编写的程序能在不同的编译器上运行，则应该避免使用像数组赋值这类依赖于编译器的非标准功能。

警告：数组的长度是固定的

与 vector 类型不同，数组不提供 push_back 或者其他的操作在数组中添加新元素，数组一经定义，就不允许再添加新元素。

如果必须在数组中添加新元素，程序员就必须自己管理内存：要求系统重新分配一个新的内存空间用于存放更大的数组，然后把原数组的所有元素复制到新分配的内存空间中。

数组操作

与vector元素一样，数组元素可用下标操作符来访问，数组元素也是从 0 开始计数。对于一个包含 10 个元素的数组，正确的下标值是从 0 到 9，而不是从 1 到 10。

在用下标访问元素时，vector 使用 vector::size_type 作为下标的类型，而数组下标的正确类型则是size_t.

在下面的例子中，for 循环遍历数组的 10 个元素，并以其下标值作为各个元素的初始值：

          int main()
          {
              const size_t array_size = 10;
              int ia[array_size]; // 10 ints, elements are uninitialized

              // loop through array, assigning value of its index to each element
              for (size_t ix = 0; ix != array_size; ++ix)
                    ia[ix] = ix;
              return 0;
          }

使用类似的循环，可以实现把一个数组复制给另一个数组：

          int main()
          {
              const size_t array_size = 7;
              int ia1[] = { 0, 1, 2, 3, 4, 5, 6 };
              int ia2[array_size]; // local array, elements uninitialized

              // copy elements from ia1 into ia2
              for (size_t ix = 0; ix != array_size; ++ix)
                    ia2[ix] = ia1[ix];
              return 0;
          }

检查数组下标值

正如 string 和 vector 类型，程序员在使用数组时，也必须保证其下标值在正确范围之内，即数组在该下标位置应对应一个元素。

除了程序员自己注意细节，并彻底测试自己的程序之外，没有别的办法可防止数组越界。通过编译并执行的程序仍然存在致命的错误，这并不是不可能的。

<Beware>;

致安全问题的最常见原因是所谓“缓冲区溢出（buffer overflow）”错误。当我们在编程时没有检查下标，并且引用了越出数组或其他类似数据结构边界的元素时，就会导致这类错误。