声明数组类型的对象。

语法

数组声明是简单声明，其声明符拥有如下形式

形式为 T a[N]; 的声明，将 a 声明为由 N 个连续分配的 T 类型对象所组成的数组对象。数组元素拥有编号 0, …, N - 1，且可通过下标运算符 [] 访问，如 a[0], …, a[N - 1]。

数组可由任何（除 void 外的）基础类型、指针、成员指针、类、枚举，或从其他已知边界数组类型（这种情况下称数组是多维的）构成。换言之，唯有未知边界数组以外的对象类型能为数组类型的元素类型。拥有不完整元素类型的数组类型亦为不完整类型。

不存在引用的数组或函数的数组。

对数组类型（通过 typedef 或模板操作）应用 cv 限定符，会将限定符应用到其元素类型，但元素为 cv 限定类型的任何数组类型，则被认为拥有相同的 cv 限定性。

// a 与 b 拥有相同的 const 限定类型“const char 的 5 元素数组”
typedef const char CC;
CC a[5] = {}; 
typedef char CA[5];
const CA b = {};

在用于 new[] 表达式时，数组的大小可以为零；这种数组无元素：

int* p = new int[0]; // 访问 p[0] 或 *p 是未定义的
delete[] p; // 仍然要求清理

赋值

数组类型的对象不能作为整体修改：虽然它们是左值（即能取数组地址），但它们不能出现在赋值运算符的左侧：

int a[3] = {1, 2, 3}, b[3] = {4, 5, 6};
int (*p)[3] = &a; // OK：能取地址
a = b;            // 错误：a 是数组
struct { int c[3]; } s1, s2 = {3, 4, 5};
s1 = s2; // OK：隐式定义的复制赋值运算符可对数组类型的数据成员赋值

数组到指针的退化

存在从数组类型的左值和右值到指针类型的右值的隐式转换：它构造一个指向数组首元素的指针。凡在数组出现于不期待数组而期待指针的语境中时，均使用这个转换：

运行此代码

#include <iostream>
#include <numeric>
#include <iterator>
 
void g(int (&a)[3])
{
    std::cout << a[0] << '\n';
}
 
void f(int* p)
{
    std::cout << *p << '\n';
}
 
int main()
{
    int a[3] = {1, 2, 3};
    int* p = a;
 
    std::cout << sizeof a << '\n'  // 打印数组的大小
              << sizeof p << '\n'; // 打印指针的大小
 
    // 在可接受数组，而不可接受指针处，只能使用数组
    g(a); // OK：函数以引用接受数组
//  g(p); // error
 
    for(int n: a)              // OK：数组可用于范围 for 循环
        std::cout << n << ' '; // 打印数组的各个元素
//  for(int n: p)              // 错误
//      std::cout << n << ' ';
 
    std::iota(std::begin(a), std::end(a), 7); // OK：begin 与 end 接受数组
//  std::iota(std::begin(p), std::end(p), 7); // 错误
 
    // 在可接受指针，而不可接受数组处，都可以使用
    f(a); // OK：函数接受指针
    f(p); // OK：函数接受指针
 
    std::cout << *a << '\n' // 打印首元素
              << *p << '\n' // 相同
              << *(a + 1) << ' ' << a[1] << '\n'  // 打印第二元素
              << *(p + 1) << ' ' << p[1] << '\n'; // 相同
}

多维数组

当数组的元素类型是另一数组时，称该数组是多维的：

// int 的 3 元素数组的 2 元素数组
int a[2][3] = {{1, 2, 3},
               {4, 5, 6}}; // 可视作 2 × 3 矩阵，以行为主布局

注意，应用数组到指针退化时，多维数组转换成指向其首元素的指针（例如，指向其首行或首平面的指针）：数组到指针退化仅应用一次。

int a[2];            // int 的 2 元素数组
int* p1 = a;         // 退化到指向 a 首元素的指针
 
int b[2][3];         // int 的 3 元素数组的 2 元素数组
// int** p2 = b;     // 错误：b 不退化到 int**
int (*p2)[3] = b;    // b 退化到指向 b 的首个 3 元素行的指针
 
int c[2][3][4];      // int 的 4 元素数组的 3 元素数组的 2 元素数组
// int*** p3 = c;    // 错误：c 不退化到 int***
int (*p3)[3][4] = c; // c 退化到指向 c 首个 3 × 4 元素平面的指针

未知边界数组

若在数组声明中省略 表达式，则声明的类型是“T 的未知边界数组”，这是一种不完整类型，除非在声明时带有聚合初始化器：

extern int x[];      // x 的类型是“int 的未知边界数组”
int a[] = {1, 2, 3}; // a 的类型是“int 的 3 元素数组”

因为数组元素不能具有未知边界数组类型，故多维数组除了第一个之外维度中不能有未知边界：

extern int a[][2]; // OK：int 的 2 元素数组的未知边界数组
extern int b[2][]; // 错误：数组有不完整类型

可以构成到未知边界数组的引用和指针，但不能从已知边界的数组或指向已知边界数组的指针对其初始化或赋值。注意在 C 程序语言中，指向未知边界数组的指针与指向已知边界数组的指针兼容，从而可以双向转换、赋值。

extern int a1[];
int (&r1)[] = a1;  // OK
int (*p1)[] = &a1; // OK
int (*q)[2] = &a1; // 错误（但 C 中 OK）
 
int a2[] = {1, 2, 3};
int (&r2)[] = a2;  // 错误
int (*p2)[] = &a2; // 错误（但 C 中 OK）

指向未知边界数组的指针不能参与指针算术且不能用在下标运算符的左侧，但可以解引用。到未知边界数组的指针和引用不能用于函数形参中 (C++14 前)。

数组右值

尽管数组无法从函数按值返回，且不能作为大多数转型表达式的目标，数组纯右值亦可通过使用类型别名构成，并用花括号初始化的函数式转型来构造数组的临时量。

可以由访问类右值的数组成员，或用 std::move 或其他返回右值引用的转型或函数调用，直接构成数组的亡值。

运行此代码

#include <iostream>
#include <type_traits>
#include <utility>
 
void f(int (&&x)[2][3])
{
    std::cout << sizeof x << '\n';
}
 
struct X
{
    int i[2][3];
} x;
 
template<typename T> using identity = T;
 
int main()
{
    std::cout << sizeof X().i << '\n';           // 数组的大小
    f(X().i);                                    // OK：绑定到亡值
//  f(x.i);                                      // 错误：不能绑定到左值
 
    int a[2][3];
    f(std::move(a));                             // OK：绑定到亡值
 
    using arr_t = int[2][3];
    f(arr_t{});                                  // OK：绑定到纯右值
    f(identity<int[][3]>{{1, 2, 3}, {4, 5, 6}}); // OK：绑定到纯右值
 
}

输出：

24
24
24
24
24