C/C++编程：C风格数组

约定不等于承诺〃 2022-11-06 06:56 151阅读 0赞

# 声明 #

// 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'; // 相同
    }

![在这里插入图片描述][20210308161156243.png]

# 多维数组 #

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

// 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++17 起) 与类的纯右值类似，数组的纯右值由临时量实质化在求值时转换成亡值。

可以由访问类右值的数组成员，或用 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：绑定到纯右值
    
    }

![在这里插入图片描述][20210308162012454.png]

[20210308161156243.png]: /images/20221023/f2a9e9fa2d8b4d5dae54fd60cd2fa85c.png
[20210308162012454.png]: /images/20221023/211d0ab0975a474484bdb8edb4006e77.png