数组声明

声明数组类型的对象。

语法

数组声明是简单声明，它的声明符拥有如下形式：


非指针声明符 `[` 表达式(可选) `]` 属性(可选)

非指针声明符	-	任意有效的声明符，但在以 `*`、`&` 或 `&&` 起始时必须用括号环绕。
表达式	-	求值为大于零的值的整型常量表达式 (C++14 前) std::size_t 类型的经转换常量表达式 (C++14 起)
属性	-	(C++11 起) 可选的属性列表

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

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

在数组的指针或引用的声明中，可以将可能受约束的 (C++20 起) auto 说明符作为数组元素类型，这会从初始化器或函数实参 (C++14 起)推导元素类型，例如 a 是 int[42] 类型左值时 auto (*p)[42] = &a; 合法。

(C++11 起)

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

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

// a 与 b 拥有相同的 const 限定类型“含有 5 个 const char 元素的数组”
 
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); // 错误
 
    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'; // 相同
}

多维数组

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

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

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

int a[2];            // 含有 2 个 int 元素的数组
int* p1 = a;         // 退化到指向 a 的首元素的指针
 
int b[2][3];         // 含有 2 个【含有 3 个 int 元素的数组】元素的数组
// int** p2 = b;     // 错误：b 不退化到 int**
int (*p2)[3] = b;    // b 退化到指向 b 的首个 3 元素行的指针
 
int c[2][3][4];      // 含有 2 个【含有 3 个【含有 4 个 int 元素的数组】元素的数组】元素的数组
// 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 的类型是“含有 3 个 int 元素的数组”

因为数组元素不能具有未知边界数组类型，所以多维数组只能在第一个维度中有未知边界：

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

当有数组边界被省略时，如果之前的实体声明中有指定该边界，那么被省略的边界被视为与先前声明（也包含类中的静态数据成员定义）的该边界相同：

extern int x[10];
struct S
{
    static int y[10];
};
 
int x[];               // OK：边界是 10
int S::y[];            // OK：边界是 10
 
void f()
{
    extern int x[];
    int i = sizeof(x); // 错误：对象类型不完整
}

可以构成到未知边界数组的引用和指针，但不能从已知边界的数组或指向已知边界数组的指针对它进行初始化或赋值。注意在 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++17 起)

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