• A contiguously allocated memory
    • Fixed number of objects (The array size cannot be changed)

    • Its element type can be any fundamental type (int, float, bool, etc), structure, class, pointer, enumeration, 

      1. int num_array1[5]; //uninitialized array, random values 
      2. int num_array2[5] = {0, 1, 2, 3, 4}; //initialization

      上面所说的数组是定长数组，长度固定，下面来看变长数组 Variable-length arrays。

    • If the length is not an integer constant expression, the array will be a variable-length one.

      1. int len = 1;
      2. while ( len < 10 )
      3. {
      4.   int num_array2[len]; //variable-length array
      5.   cout << "len = " << len;
      6.   cout << ", sizeof(num_array2)) = " << sizeof(num_array2) << endl;
      7.   len ++;
      8. }
      1. // results
      2. sizeof(num_array1) = 20
      3. len = 0, sizeof(num_array2)) = 0
      4. len = 1, sizeof(num_array2)) = 4
      5. len = 2, sizeof(num_array2)) = 8
      6. len = 3, sizeof(num_array2)) = 12
      7. len = 4, sizeof(num_array2)) = 16
      8. len = 5, sizeof(num_array2)) = 20
      9. len = 6, sizeof(num_array2)) = 24
      10. len = 7, sizeof(num_array2)) = 28
      11. len = 8, sizeof(num_array2)) = 32
      12. len = 9, sizeof(num_array2)) = 36

      变长数组不可以创建的时候初始化，只能先声明，然后逐个元素赋值。

    未知长度的数组

    • The number is not specified in the declaration. 

      1. int num_array[ ] = {1, 2, 3, 4}; // the type of num_array is "array of 4 int"

      再编译器编译的时候，后面有几个元素，该数组就是多长。

    • The arguments of a function

      1. float array_sum(float values[], size_t length);
      2. float array_sum(float *values, size_t length);

      第二中应用场景：函数参数。values相当于指针，数组首个元素的首地址

    读写数组元素: Element accessing

    1. int array1[4] = {9,8,7,6};
    2. int array2[4];
    3. array2 = array1; //error!
    4. array2[0] = array1[0]; //okay
    5. array2[1] = array1[1]; //okay
    6. array2[2] = array1[2]; //okay
    7. array2[3] = array1[3]; //okay

    数组的名字起始代表着数组的首地址。如果第三行代码可行，数组一二的首地址相同，指向的都是同一块地址空间。所以C/C++对于这种写法错误。
    复制数组的方法：

    1. 逐个赋值
    2. 内存拷贝 | image.png |
      - Arrays are not objects（对象） in C/C++ (different with Java);
      - Arrays can be regarded as addresses

      | | —- | —- |

    No bounds-checking in C/C++. C/C++没有边界检查，如果越界，没有警告。编程时一定要谨慎，小心修改别的数组中的内容，这种bug异常难排查。其优点就是：没有边界检查，使读写的效率变高

    int num_array[5]; 
for(int idx = -1; idx <= 5; idx++)
    num_array[idx] = idx * idx;
for(int idx = -1; idx <= 5; idx++)
    cout << num_array[idx] << endl;

    // results
num_array[-1] = 1
num_array[0] = 0
num_array[1] = 1
num_array[2] = 4
num_array[3] = 9
num_array[4] = 16
num_array[5] = 25

    如果超过程序内存边界，编译器才会杀死程序。

    多维数组：Multidimensional arrays

    | image.png | ```cpp int mat[2][3] = {{11,12,13}, {14,15,16}}; for (int r = 0; r < rows; r++) { for(int c = 0; c < cols; c++) cout << mat[r][c] << “,”; cout << endl; }

    <br />- rows为2，cols为3，否则就会数组越界<br /> |
| --- | --- |

Arrays of unknown bound
```cpp
void init_2d_array(float mat[][], //error
                   size_t rows, size_t cols)

void init_2d_array(float mat[][3], 
                     size_t rows, size_t cols)

    必须要指定列数，否则编译器不知道一个二维数组的第二行从什么未知开始

    常量数组 const Arrays

    const float PI = 3.1415926f;
PI += 1.f; // error
const float values[4] = {1.1f, 2.2f, 3.3f, 4.4f};
values[0] = 1.0f; // error

    初始化完毕之后，其值不可改变。
    Used as function arguments，只对该函数进行读操作，不进行写操作

    // const-array.cpp
float array_sum(const float values[], size_t length)
{
    float sum = 0.0f;
    for (int i = 0; i < length; i++)
    {
        sum += values[i];
        //values[i] = 0; //error
    }
    return sum;
}

int main()
{
    float values[4] = {1.1f, 2.2f, 3.3f, 4.4f};
    float sum = array_sum(values, 4);
}