如何在 C++ 中使用数组？

Question

C++ 从 C 继承了数组，它们几乎无处不在。 C++ 提供了更易于使用且不易出错的抽象（自 C++98 和 std::array自 C++11)，因此对数组的需求并不像 C 中那样频繁出现。但是，当您阅读遗留代码或进行交互时有了用 C 编写的库，您应该牢牢掌握数组的工作原理。

此常见问题解答分为五个部分：

1. 类型级别的数组和访问元素
2. 数组创建和初始化
3. 赋值和参数传递
4. 多维数组和指针数组
5. 使用数组时的常见陷阱

如果您觉得此常见问题解答中缺少一些重要内容，请写下答案并将其链接到此处作为附加部分。

在下面的文本中，“array”表示“C 数组”，而不是类模板 std::array。假设您具备 C 声明符语法的基本知识。请注意，如下所示，手动使用 new 和 delete 在遇到异常时极其危险，但这就是 另一个常见问题解答。

---

_{（注意：这是 Stack Overflow 的 C++ FAQ 的条目。如果您想要批评以这种形式提供常见问题解答的想法，然后 开始这一切的元上的帖子将是执行该操作的地方，该问题的答案将在C++ 聊天室，FAQ 想法最初是从这里开始的，因此您的答案很可能会被提出该想法的人阅读。）}

Answer 1

类型级别的数组

数组类型表示为 T[n]，其中 T 是元素类型，n > 是正数大小，即数组中元素的数量。数组类型是元素类型和大小的乘积类型。如果这些成分中的一个或两个不同，您将得到一个不同的类型：

#include <type_traits>

static_assert(!std::is_same<int[8], float[8]>::value, "distinct element type");
static_assert(!std::is_same<int[8],   int[9]>::value, "distinct size");

请注意，大小是类型的一部分，也就是说，不同大小的数组类型是不兼容的类型，彼此之间完全没有任何关系。 sizeof(T[n]) 相当于 n * sizeof(T)。

数组到指针的衰减

T[n] 和 T[m] 之间的唯一“联系”是这两种类型都可以隐式转换到 T*，此转换的结果是指向数组第一个元素的指针。也就是说，任何需要 T* 的地方，您都可以提供 T[n]，编译器将默默地提供该指针：

                  +---+---+---+---+---+---+---+---+
the_actual_array: |   |   |   |   |   |   |   |   |   int[8]
                  +---+---+---+---+---+---+---+---+
                    ^
                    |
                    |
                    |
                    |  pointer_to_the_first_element   int*

这种转换称为“数组- to-pointer 衰减”，这是造成混乱的一个主要根源。在此过程中数组的大小会丢失，因为它不再是类型的一部分 (T*)。优点：在类型级别上忘记数组的大小允许指针指向任何大小的数组的第一个元素。缺点：给定一个指向数组第一个（或任何其他）元素的指针，无法检测该数组有多大或指针相对于数组边界到底指向哪里。 指针极其愚蠢。

数组不是指针

只要认为有用，即每当操作在数组上失败但在指针上成功时，编译器就会默默地生成一个指向数组第一个元素的指针。从数组到指针的转换很简单，因为生成的指针值只是数组的地址。请注意，指针不存储为数组本身的一部分（或内存中的任何其他位置）。 数组不是指针。

static_assert(!std::is_same<int[8], int*>::value, "an array is not a pointer");

数组不会衰减为指向其第一个元素的指针的一个重要上下文是当&运算符应用于它。在这种情况下，& 运算符会生成一个指向整个数组的指针，而不仅仅是指向其第一个元素的指针。尽管在这种情况下，值（地址）相同，但指向数组第一个元素的指针和指向整个数组的指针是完全不同的类型：

static_assert(!std::is_same<int*, int(*)[8]>::value, "distinct element type");

以下 ASCII 艺术解释了这种区别：

      +-----------------------------------+
      | +---+---+---+---+---+---+---+---+ |
+---> | |   |   |   |   |   |   |   |   | | int[8]
|     | +---+---+---+---+---+---+---+---+ |
|     +---^-------------------------------+
|         |
|         |
|         |
|         |  pointer_to_the_first_element   int*
|
|  pointer_to_the_entire_array              int(*)[8]

请注意，指向第一个元素的指针仅指向单个整数（描绘为小方框），而指向整个数组的指针则指向包含 8 个整数的数组（描绘为大方框）。

同样的情况也出现在课堂上，而且可能更为明显。指向对象的指针和指向其第一个数据成员的指针具有相同的值（相同的地址），但它们是完全不同的类型。

如果您不熟悉 C 声明符语法，则类型 int(*)[8] 中的括号是必不可少的：

• int(*)[8] 是指向8 个整数的数组。
• int*[8] 是一个由 8 个指针组成的数组，每个元素的类型为 int*。

访问元素

C++ 提供了两种语法变体来访问数组的各个元素。
它们之间没有谁比谁优越，您应该熟悉两者。

指针算术

给定一个指向数组第一个元素的指针 p，表达式 p+i 将生成一个指向数组第 i 个元素的指针。之后通过取消引用该指针，可以访问单个元素：

std::cout << *(x+3) << ", " << *(x+7) << std::endl;

如果 x 表示一个数组，那么数组到指针的衰减就会开始，因为添加一个数组和一个整数没有意义（数组上没有加法运算），但是指针和整数相加就有意义了：（

   +---+---+---+---+---+---+---+---+
x: |   |   |   |   |   |   |   |   |   int[8]
   +---+---+---+---+---+---+---+---+
     ^           ^               ^
     |           |               |
     |           |               |
     |           |               |
x+0  |      x+3  |          x+7  |     int*

注意隐式生成的指针没有名字，所以我写了x+0以便识别另一方面

，如果 x 表示指向数组第一个（或任何其他）元素的指针，则数组到指针的衰减不是必要的，因为要添加的 i 指针已经存在：

   +---+---+---+---+---+---+---+---+
   |   |   |   |   |   |   |   |   |   int[8]
   +---+---+---+---+---+---+---+---+
     ^           ^               ^
     |           |               |
     |           |               |
   +-|-+         |               |
x: | | |    x+3  |          x+7  |     int*
   +---+

请注意，在所描述的情况下，x 是一个指针变量（可以通过 x 旁边的小框辨别），但它也可能是返回指针（或任何其他类型 T* 的其他表达式）的函数的结果。

索引运算符

由于语法 *(x+i) 有点笨拙，C++ 提供了替代语法 x[i]：

std::cout << x[3] << ", " << x[7] << std::endl;

由于加法是可交换的，因此以下代码的作用完全相同：

std::cout << 3[x] << ", " << 7[x] << std::endl;

索引运算符的定义导致以下有趣的等价：

&x[i]  ==  &*(x+i)  ==  x+i

但是，&x[0] 通常不等于x。前者是指针，后者是数组。只有当上下文触发数组到指针的衰减时，x 和 &x[0] 才能互换使用。例如：

T* p = &array[0];  // rewritten as &*(array+0), decay happens due to the addition
T* q = array;      // decay happens due to the assignment

在第一行，编译器检测到从指针到指针的赋值，这很容易成功。在第二行，它检测从数组到指针的赋值。由于这是毫无意义的（但是指针到指针的赋值是有意义的），因此数组到指针的衰减像往常一样开始。

范围

T[n] 类型的数组有 n 个元素，索引从 0 到 n-1；没有元素n。然而，为了支持半开范围（其中开头包含，结尾排除），C++允许计算指向（不存在的）的指针第 n 个元素，但取消引用该指针是非法的：

   +---+---+---+---+---+---+---+---+....
x: |   |   |   |   |   |   |   |   |   .   int[8]
   +---+---+---+---+---+---+---+---+....
     ^                               ^
     |                               |
     |                               |
     |                               |
x+0  |                          x+8  |     int*

例如，如果要对数组进行排序，则以下两种方法同样有效：

std::sort(x + 0, x + n);
std::sort(&x[0], &x[0] + n);

请注意，提供 &x[n] 是非法的 作为第二个参数，因为这相当于 &*(x+n)，并且子表达式 *(x+n) 技术上调用 < a href="https://stackoverflow.com/questions/3144904/">C++ 中的未定义行为（但 C99 中则不然）。

另请注意，您可以简单地提供 x 作为第一个参数。这对我来说有点太简洁了，而且它也使编译器的模板参数推导变得有点困难，因为在这种情况下，第一个参数是一个数组，但第二个参数是一个指针。 （数组到指针的衰减再次开始。）

Answer 2

程序员经常将多维数组与指针数组混淆。

多维数组

大多数程序员都熟悉命名多维数组，但许多人不知道多维数组也可以匿名创建。多维数组通常称为“数组的数组”或“真正多维数组”。

命名多维数组

当使用命名多维数组时，所有维度必须在编译时已知：

int H = read_int();
int W = read_int();

int connect_four[6][7];   // okay

int connect_four[H][7];   // ISO C++ forbids variable length array
int connect_four[6][W];   // ISO C++ forbids variable length array
int connect_four[H][W];   // ISO C++ forbids variable length array

这就是命名多维数组在内存中的样子：

              +---+---+---+---+---+---+---+
connect_four: |   |   |   |   |   |   |   |
              +---+---+---+---+---+---+---+
              |   |   |   |   |   |   |   |
              +---+---+---+---+---+---+---+
              |   |   |   |   |   |   |   |
              +---+---+---+---+---+---+---+
              |   |   |   |   |   |   |   |
              +---+---+---+---+---+---+---+
              |   |   |   |   |   |   |   |
              +---+---+---+---+---+---+---+
              |   |   |   |   |   |   |   |
              +---+---+---+---+---+---+---+

请注意，如上所述的 2D 网格仅仅是有用的可视化。从 C++ 的角度来看，内存是一个“扁平”的字节序列。多维数组的元素按行优先顺序存储。也就是说，connect_four[0][6] 和 connect_four[1][0] 是内存中的邻居。事实上，connect_four[0][7] 和 connect_four[1][0] 表示同一个元素！这意味着您可以采用多维数组并将它们视为大型一维数组：

int* p = &connect_four[0][0];
int* q = p + 42;
some_int_sequence_algorithm(p, q);

匿名多维数组

对于匿名多维数组，除第一个维度外的所有维度都必须在编译时已知：

int (*p)[7] = new int[6][7];   // okay
int (*p)[7] = new int[H][7];   // okay

int (*p)[W] = new int[6][W];   // ISO C++ forbids variable length array
int (*p)[W] = new int[H][W];   // ISO C++ forbids variable length array

这是匿名多维数组在内存中的样子：

              +---+---+---+---+---+---+---+
        +---> |   |   |   |   |   |   |   |
        |     +---+---+---+---+---+---+---+
        |     |   |   |   |   |   |   |   |
        |     +---+---+---+---+---+---+---+
        |     |   |   |   |   |   |   |   |
        |     +---+---+---+---+---+---+---+
        |     |   |   |   |   |   |   |   |
        |     +---+---+---+---+---+---+---+
        |     |   |   |   |   |   |   |   |
        |     +---+---+---+---+---+---+---+
        |     |   |   |   |   |   |   |   |
        |     +---+---+---+---+---+---+---+
        |
      +-|-+
   p: | | |
      +---+

请注意，数组本身仍然在内存中分配为单个块。

指针数组

您可以通过引入另一层间接寻址来克服固定宽度的限制。

命名的指针数组

这是一个由五个指针组成的命名数组，它们使用不同长度的匿名数组进行初始化：

int* triangle[5];
for (int i = 0; i < 5; ++i)
{
    triangle[i] = new int[5 - i];
}

// ...

for (int i = 0; i < 5; ++i)
{
    delete[] triangle[i];
}

这是它在内存中的样子：

          +---+---+---+---+---+
          |   |   |   |   |   |
          +---+---+---+---+---+
            ^
            | +---+---+---+---+
            | |   |   |   |   |
            | +---+---+---+---+
            |   ^
            |   | +---+---+---+
            |   | |   |   |   |
            |   | +---+---+---+
            |   |   ^
            |   |   | +---+---+
            |   |   | |   |   |
            |   |   | +---+---+
            |   |   |   ^
            |   |   |   | +---+
            |   |   |   | |   |
            |   |   |   | +---+
            |   |   |   |   ^
            |   |   |   |   |
            |   |   |   |   |
          +-|-+-|-+-|-+-|-+-|-+
triangle: | | | | | | | | | | |
          +---+---+---+---+---+

由于现在每行都是单独分配的，因此将 2D 数组视为 1D 数组不再起作用。

匿名指针数组

这是一个由 5 个（或任何其他数量）指针组成的匿名数组，它们是用不同长度的匿名数组初始化的：

int n = calculate_five();   // or any other number
int** p = new int*[n];
for (int i = 0; i < n; ++i)
{
    p[i] = new int[n - i];
}

// ...

for (int i = 0; i < n; ++i)
{
    delete[] p[i];
}
delete[] p;   // note the extra delete[] !

下面是它在内存中的样子：

          +---+---+---+---+---+
          |   |   |   |   |   |
          +---+---+---+---+---+
            ^
            | +---+---+---+---+
            | |   |   |   |   |
            | +---+---+---+---+
            |   ^
            |   | +---+---+---+
            |   | |   |   |   |
            |   | +---+---+---+
            |   |   ^
            |   |   | +---+---+
            |   |   | |   |   |
            |   |   | +---+---+
            |   |   |   ^
            |   |   |   | +---+
            |   |   |   | |   |
            |   |   |   | +---+
            |   |   |   |   ^
            |   |   |   |   |
            |   |   |   |   |
          +-|-+-|-+-|-+-|-+-|-+
          | | | | | | | | | | |
          +---+---+---+---+---+
            ^
            |
            |
          +-|-+
       p: | | |
          +---+

转换

数组到指针的衰减自然延伸到数组数组和指针数组：

int array_of_arrays[6][7];
int (*pointer_to_array)[7] = array_of_arrays;

int* array_of_pointers[6];
int** pointer_to_pointer = array_of_pointers;

但是，没有从 T[h][w] 到 T** 的隐式转换。如果确实存在这样的隐式转换，则结果将是指向指向 T 的 h 指针数组的第一个元素的指针（每个指针都指向一行的第一个元素）在原始的二维数组中），但是该指针数组在内存中的任何位置都不存在。如果您想要进行此类转换，则必须手动创建并填充所需的指针数组：

int connect_four[6][7];

int** p = new int*[6];
for (int i = 0; i < 6; ++i)
{
    p[i] = connect_four[i];
}

// ...

delete[] p;

请注意，这会生成原始多维数组的视图。如果您需要副本，则必须创建额外的数组并自行复制数据：

int connect_four[6][7];

int** p = new int*[6];
for (int i = 0; i < 6; ++i)
{
    p[i] = new int[7];
    std::copy(connect_four[i], connect_four[i + 1], p[i]);
}

// ...

for (int i = 0; i < 6; ++i)
{
    delete[] p[i];
}
delete[] p;

Answer 3

赋值

没有特殊原因，数组之间不能相互赋值。使用 std::copy 代替：

#include <algorithm>

// ...

int a[8] = {2, 3, 5, 7, 11, 13, 17, 19};
int b[8];
std::copy(a + 0, a + 8, b);

这比真正的数组赋值更灵活，因为可以将较大数组的切片复制到较小的数组中。
std::copy 通常专门用于原始类型以提供最大性能。 std::memcpy 不太可能表现得更好。如有疑问，请进行测量。

虽然您不能直接分配数组，但您可以分配包含数组成员的结构和类。这是因为编译器默认提供的赋值运算符数组成员按成员复制。如果您为自己的结构或类类型手动定义赋值运算符，则必须回退到手动复制数组成员。

参数传递

数组不能按值传递。您可以通过指针或引用传递它们。

通过指针传递

由于数组本身不能按值传递，因此通常会按值传递指向其第一个元素的指针。这通常称为“通过指针传递”。由于无法通过该指针检索数组的大小，因此必须传递第二个参数来指示数组的大小（经典的 C 解决方案）或指向数组最后一个元素之后的第二个指针（C++ 迭代器解决方案） ：

#include <numeric>
#include <cstddef>

int sum(const int* p, std::size_t n)
{
    return std::accumulate(p, p + n, 0);
}

int sum(const int* p, const int* q)
{
    return std::accumulate(p, q, 0);
}

作为一种语法替代，您还可以将参数声明为 T p[]，它与参数上下文中的 T* p 含义完全相同仅列表：

int sum(const int p[], std::size_t n)
{
    return std::accumulate(p, p + n, 0);
}

您可以将编译器视为将 T p[] 重写为 T *p 仅在参数列表的上下文中。这个特殊规则是造成数组和指针混乱的部分原因。在所有其他上下文中，将某些内容声明为数组或指针都会产生巨大的差异。

不幸的是，您还可以在数组参数中提供一个大小，该大小会被编译器默默地忽略。也就是说，以下三个签名完全等效，如编译器错误所示：

int sum(const int* p, std::size_t n)

// error: redefinition of 'int sum(const int*, size_t)'
int sum(const int p[], std::size_t n)

// error: redefinition of 'int sum(const int*, size_t)'
int sum(const int p[8], std::size_t n)   // the 8 has no meaning here

按引用传递

数组也可以按引用传递：

int sum(const int (&a)[8])
{
    return std::accumulate(a + 0, a + 8, 0);
}

在这种情况下，数组大小很重要。由于编写只接受恰好 8 个元素的数组的函数没什么用处，因此程序员通常将此类函数编写为模板：

template <std::size_t n>
int sum(const int (&a)[n])
{
    return std::accumulate(a + 0, a + n, 0);
}

请注意，只能使用实际的整数数组调用此类函数模板，而不能使用指向整数的指针。数组的大小是自动推断的，对于每个大小n，都会从模板实例化一个不同的函数。您还可以编写相当有用的函数模板，从元素类型和大小中进行抽象。

Answer 4

5. 使用数组时的常见陷阱。

5.1 陷阱：信任类型不安全的链接。

好吧，你已经被告知，或者你自己发现了，全局变量（命名空间
可以在翻译单元之外访问的范围变量）是
邪恶™。但您知道它们有多真实吗？考虑
下面的程序，由两个文件 [main.cpp] 和 [numbers.cpp] 组成：

// [main.cpp]
#include <iostream>

extern int* numbers;

int main()
{
    using namespace std;
    for( int i = 0;  i < 42;  ++i )
    {
        cout << (i > 0? ", " : "") << numbers[i];
    }
    cout << endl;
}

// [numbers.cpp]
int numbers[42] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

在 Windows 7 中，该程序可以与 MinGW g++ 4.4.1 和
视觉C++10.0。

由于类型不匹配，程序在运行时会崩溃。

正式解释：该程序具有未定义行为 (UB)，而是
因此，崩溃时它可能会挂起，或者什么都不做，或者它
可以向美国、俄罗斯、印度总统发送威胁电子邮件，
中国和瑞士，让鼻恶魔从你的鼻子里飞出来。

实践说明：在main.cpp中，数组被视为指针，放置在
与数组位于同一地址。对于 32 位可执行文件，这意味着第一个
数组中的int值被视为指针。即，在 main.cpp 中
numbers 变量包含或似乎包含 (int*)1。这导致
程序访问地址空间最底部的内存，即
传统上保留并导致陷阱。结果：你会崩溃。

编译器完全有权不诊断此错误，
因为 C++11 §3.5/10 说，关于兼容类型的要求
对于声明，

[N3290 §3.5/10]
违反此类型标识规则不需要诊断。

同一段详细说明了允许的变化：

…数组对象的声明可以指定数组类型
因是否存在主数组边界而有所不同 (8.3.4)。

这种允许的变化不包括将名称声明为一个数组
翻译单元，并作为另一个翻译单元中的指针。

5.2 陷阱：过早优化（memset 和朋友）。

尚未编写

5.3 陷阱：使用 C 惯用法获取元素数量。

凭借深厚的 C 经验，很自然地可以这样写……

#define N_ITEMS( array )   (sizeof( array )/sizeof( array[0] ))

由于数组会在需要时衰减为指向第一个元素的指针，因此
表达式 sizeof(a)/sizeof(a[0]) 也可以写成
sizeof(a)/sizeof(*a)。不管怎样，意思都是一样的
它是用于查找数组元素的C 惯用法。

主要陷阱：C 习惯用法不是类型安全的。例如，代码
...

#include <stdio.h>

#define N_ITEMS( array ) (sizeof( array )/sizeof( *array ))

void display( int const a[7] )
{
    int const   n = N_ITEMS( a );          // Oops.
    printf( "%d elements.\n", n );
}

int main()
{
    int const   moohaha[]   = {1, 2, 3, 4, 5, 6, 7};

    printf( "%d elements, calling display...\n", N_ITEMS( moohaha ) );
    display( moohaha );
}

传递一个指向N_ITEMS的指针，因此很可能会产生错误
结果。在 Windows 7 中编译为 32 位可执行文件，它会生成……

7个元素，调用显示...
1 个元素。

1. 编译器将 int const a[7] 重写为 int const a[]。
2. 编译器将 int const a[] 重写为 int const* a。
3. 因此，N_ITEMS 是通过指针调用的。
4. 对于 32 位可执行文件，sizeof(array)（指针的大小）为 4。
5. sizeof(*array) 相当于 sizeof(int)< /code>，对于 32 位可执行文件也是 4。

为了在运行时检测此错误，您可以执行以下操作：

#include <assert.h>
#include <typeinfo>

#define N_ITEMS( array )       (                               \
    assert((                                                    \
        "N_ITEMS requires an actual array as argument",        \
        typeid( array ) != typeid( &*array )                    \
        )),                                                     \
    sizeof( array )/sizeof( *array )                            \
    )

7个元素，调用显示...
断言失败：(“N_ITEMS 需要一个实际数组作为参数”，typeid( a ) != typeid( &*a ) )，文件 runtime_detect
ion.cpp，第 16 行

此应用程序已请求运行时以异常方式终止它。
请联系应用程序的支持团队以获取更多信息。

运行时错误检测比不检测好，但是有点浪费
处理器时间，也许还有更多的程序员时间。更好地检测
编译时间！如果您很高兴不支持 C++98 的本地类型数组，
那么你可以这样做：

#include <stddef.h>

typedef ptrdiff_t   Size;

template< class Type, Size n >
Size n_items( Type (&)[n] ) { return n; }

#define N_ITEMS( array )       n_items( array )

用 g++ 编译这个定义并代入第一个完整的程序，
我得到了……

M:\count>; g++ 编译时检测.cpp
compile_time_detection.cpp：在函数“void display(const int*)”中：
compile_time_detection.cpp：14：错误：没有匹配的函数可用于调用“n_items（const int *＆）”

M:\count>; _

工作原理：数组通过引用传递给n_items，所以它确实如此
不会衰减到指向第一个元素的指针，并且该函数可以只返回
类型指定的元素数量。

使用 C++11，您也可以将其用于本地类型的数组，并且它是类型安全的
用于查找数组元素数量的C++ 习惯用法。

5.4 C++11 - C++20 陷阱：使用 constexpr 数组大小函数。

使用 C++11 及更高版本，很自然地实现数组大小函数，如下所示：

// Similar in C++03, but not constexpr.
template< class Type, std::size_t N > 
constexpr std::size_t size( Type (&)[N] ) { return N; }

这会生成数组中的元素数量作为编译时间常量。该函数甚至被标准化为 std::size。

例如，size() 可用于声明与另一个数组大小相同的数组：

// Example 1
void foo()
{
    int const x[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 4};
    int y[ size(x) ] = {};
}

但请考虑使用 constexpr 版本的代码：

// Example 2
template< class Collection >
void foo( Collection const& c )
{
    constexpr int n = size( c ); // error prior to C++23
    // ...
}

int main()
{
    int x[42];
    foo( x );
}

陷阱：直到 C++ 23 不允许使用引用c na常量表达式，并且所有主要编译器都拒绝此代码。来自 C++20 标准，[expr.const] p5.12 ：

表达式E是核心常量表达式，除非E的计算遵循抽象机的规则，将计算以下之一以下内容：

• [...]
• 引用引用类型的变量或数据成员的id-表达式，除非该引用具有先前的初始化并且
  • 它可用于常量表达式或
  • 它的生命周期开始于 E 的评估；

c 既不能在常量表达式中使用，其生命周期也不在 constexpr int n = ... 内开始，因此计算 c 不是核心常数表达式。对于 C++23，这些限制已由 P2280：在常量表达式中使用未知的指针和引用。 c 被视为对未指定对象的引用绑定 ([ expr.const] p8）。

5.4.1 解决方法：C++20 兼容的 constexpr 大小函数

std::extentstd::extentconstexpr decltype( c ) >::value; 不是一个可行的解决方法，因为如果 Collection 不是数组，它就会失败。

为了处理可以是非数组的集合，需要一个
size 函数，而且，对于编译时使用，需要编译时
数组大小的表示。以及经典的 C++03 解决方案，效果很好
同样在 C++11 和 C++14 中，是让函数报告其结果而不是值
但通过其函数结果类型。例如这样：

// Example 3 - OK (not ideal, but portable and safe)

#include <array>
#include <cstddef>

// No implementation, these functions are never evaluated.
template< class Type, std::size_t N >
auto static_n_items( Type (&)[N] )
  -> char(&)[N]; // return a reference to an array of N chars

template< class Type, std::size_t N >
auto static_n_items( std::array<Type, N> const& )
  -> char(&)[N];

#define STATIC_N_ITEMS( c ) ( sizeof( static_n_items( c )) )

template< class Collection >
void foo( Collection const& c )
{
    constexpr std::size_t n = STATIC_N_ITEMS( c );
    // ...
}

int main()
{
    int x[42];
    std::array<int, 43> y;
    foo( x );
    foo( y );
}

关于 static_n_items 返回类型的选择：此代码不使用 std::integral_constant
因为使用 std::integral_constant 表示结果
直接作为 constexpr 值，重新引入原始问题。

关于命名：此解决方案的一部分是 constexpr-invalid-due-to-reference
问题是要明确选择编译时间常数。

在 C++23 之前，像上面的 STATIC_N_ITEMS 这样的宏会产生可移植性，
例如，对于 clang 和 Visual C++ 编译器，保留类型安全。

相关：宏不尊重范围，因此为了避免名称冲突，它可以是
使用名称前缀是个好主意，例如MYLIB_STATIC_N_ITEMS。

Answer 5

数组创建和初始化

与任何其他类型的 C++ 对象一样，数组可以直接存储在命名变量中（那么大小必须是编译时常量；C++ 不支持 VLA），或者可以将它们匿名存储在堆上并通过指针间接访问（只有这样才能在运行时计算大小）。

自动数组

每次控制流经过非静态局部数组变量的定义时，都会创建自动数组（“位于堆栈上”的数组）：

void foo()
{
    int automatic_array[8];
}

按升序执行初始化。请注意，初始值取决于元素类型 T：

• 如果 T 是 POD （如上例中的int），不进行初始化。
• 否则，T 的默认构造函数将初始化所有元素。
• 如果 T 未提供可访问的默认构造函数，则程序无法编译。

或者，可以在数组初始值设定项中显式指定初始值，这是一个用大括号括起来的逗号分隔列表：

    int primes[8] = {2, 3, 5, 7, 11, 13, 17, 19};

因为在这种情况下，数组初始值设定项中的元素数量等于数组初始值设定项的大小数组，手动指定大小是多余的。它可以由编译器自动推导：

    int primes[] = {2, 3, 5, 7, 11, 13, 17, 19};   // size 8 is deduced

还可以指定大小并提供较短的数组初始值设定项：

    int fibonacci[50] = {0, 1, 1};   // 47 trailing zeros are deduced

在这种情况下，其余元素为 零初始化。请注意，C++ 允许使用空数组初始值设定项（所有元素都初始化为零），而 C89 不允许（至少需要一个值）。另请注意，数组初始值设定项只能用于初始化数组；它们以后不能在作业中使用。

静态数组

静态数组（位于“数据段”中的数组）是使用 static 关键字定义的局部数组变量和命名空间范围内的数组变量（“全局变量”）：（

int global_static_array[8];

void foo()
{
    static int local_static_array[8];
}

请注意，命名空间范围内的变量是隐式静态的。将 static 关键字添加到其定义中具有完全不同的、已弃用的含义。）

以下是静态数组与自动数组的不同之处：

• 没有数组初始值设定项的静态数组在任何进一步的潜在初始化之前都会进行零初始化。
• 静态 POD 数组仅初始化一次，并且初始值通常被烘焙到可执行文件中，在这种情况下，运行时没有初始化成本。然而，这并不总是最节省空间的解决方案，而且标准也没有要求。
• 静态非 POD 数组在控制流第一次通过其定义时被初始化。对于本地静态数组，如果从未调用该函数，则可能永远不会发生这种情况。

（以上都不是特定于数组的。这些规则同样适用于其他类型的静态对象。）

数组数据成员

数组数据成员是在创建其所属对象时创建的。不幸的是，C++03 没有提供初始化成员初始值设定项列表中的数组的方法，因此必须通过赋值来伪造初始化：

class Foo
{
    int primes[8];

public:

    Foo()
    {
        primes[0] = 2;
        primes[1] = 3;
        primes[2] = 5;
        // ...
    }
};

或者，您可以在构造函数主体中定义一个自动数组并复制元素：

class Foo
{
    int primes[8];

public:

    Foo()
    {
        int local_array[] = {2, 3, 5, 7, 11, 13, 17, 19};
        std::copy(local_array + 0, local_array + 8, primes + 0);
    }
};

在 C++0x 中，由于 统一初始化：

class Foo
{
    int primes[8];

public:

    Foo() : primes { 2, 3, 5, 7, 11, 13, 17, 19 }
    {
    }
};

这是唯一适用于没有默认构造函数的元素类型的解决方案。

动态数组

动态数组没有名称，因此访问它们的唯一方法是通过指针。因为它们没有名字，所以从现在开始我将它们称为“匿名数组”。

在 C 中，匿名数组是通过 malloc 等创建的。在 C++ 中，匿名数组是使用 new T[size] 语法创建的，该语法返回指向匿名数组第一个元素的指针：

std::size_t size = compute_size_at_runtime();
int* p = new int[size];

以下 ASCII 艺术描述了大小计算为 8 时的内存布局运行时：

             +---+---+---+---+---+---+---+---+
(anonymous)  |   |   |   |   |   |   |   |   |
             +---+---+---+---+---+---+---+---+
               ^
               |
               |
             +-|-+
          p: | | |                               int*
             +---+

显然，由于必须单独存储额外的指针，匿名数组比命名数组需要更多的内存。 （免费存储上还有一些额外的开销。）

请注意，这里没有发生数组到指针的衰减。尽管计算 new int[size] 实际上会创建一个整数数组，但表达式 new int[size] 的结果是 >已经指向单个整数（第一个元素）的指针，不是整数数组或指向未知大小的整数数组的指针。这是不可能的，因为静态类型系统要求数组大小是编译时常量。 （因此，我没有在图中用静态类型信息注释匿名数组。）

关于元素的默认值，匿名数组的行为类似于自动数组。
通常，匿名 POD 数组不会被初始化，但是有一个特殊语法可以触发值初始化：（

int* p = new int[some_computed_size]();

注意尾随的一对分号之前的括号。）同样，C++0x 简化了规则，并允许通过统一初始化为匿名数组指定初始值：

int* p = new int[8] { 2, 3, 5, 7, 11, 13, 17, 19 };

如果使用完匿名数组，则必须将其释放回系统：

delete[] p;

您必须每个匿名数组只释放一次，然后再也不会碰它。根本不释放它会导致内存泄漏（或者更一般地说，根据元素类型，资源泄漏），并且尝试多次释放它会导致未定义的行为。使用非数组形式delete（或free）而不是delete[]来释放数组也是未定义的行为。