#include <stdio.h>
void printArray(int array[], int length)
{
    for (int i = 0; i<length; i++)
    {
        printf("array[%d] = %d \n", i, array[i]);
    }
}
void printArrayAddr(int array[])
{
     printf("array的地址是%p \n", array);
}
int main()
{    /************************************************
      *
      *    使用数组注意事项：
      *
      *  正确写法
      *
      *    1、定义数组时进行初始化  int ages[5] = {10 , 11, 12, 67, 56};
      *    2、定义数组时，只初始化部分数组元素，其他的默认为0
      *       int ages[5] = {10, 11};
      *    3、定义数组时初始化指定下标的元素
      *       int ages[5] = {[3] = 10, [4] = 11};
      *    4、如果知道数组的大小定义数组时可以省略数组的大小
      *       int ages[] = {10, 11, 14};
      *    5、使用字符或者常量或者常量的运算结果作为数组的大小
      *       int ages[‘A‘] = {10, 11, 12, 14, 16};
      *       int ages[‘A‘- 50] = {10, 11, 12, 14, 16};
      *       int ages[60 - 50] = {10, 11, 12, 14, 16};
      *    6、数组的大小使用一个变量指定，但是此时不能对数组进行初始化
      *      int count = 5;
      *      int ages[count];
      *      ages[0] = 10;
      *      ages[1] = 11;
      *      ages[2] = 18;
      *
      *   错误写法：
      *
      *    1、没有标明数组的大小  int ages[];
      *    2、在声明数组后对数组进行初始化
      *       int ages[5];
      *       ages = {10, 11, 12, 14};
      *    3、数组的大小使用一个变量指定，并且对数组进行初始化
      *      int count = 5;
      *      int ages[count] = {10, 11, 12};
      *    4、使用类似其他语言声明数组的方法：
      *      int[5] ages;
      *
      *   计算数组的长度：
      *      int count = sizeof(ages)/sizeof(int);
      *   当一个函数的参数是数组时，如果我们传递一个数组名调用函数此时传递的是数组的地址，
      *   当我们在函数中对数组中相应位置的数据进行修改，此时修改的是数组中的数据
      *
      *   二维数组:二位数组可以看做是数组的数组，比如a[2][2]是由a[0]和a[1]组成，
      *   其中a[0]包含a[0][0],a[0][1],a[1]包含a[1][0],a[1][1].
      *
      ***************************************************/

      //1、定义数组时进行初始化  int ages[5] = {10 , 11, 12, 67, 56};
       printf("1、定义数组时进行初始化  int ages[5] = {10 , 11, 12, 67, 56};\n");
       int ages[5] = {10 , 11, 12, 67, 56};
       printArray(ages,sizeof(ages)/sizeof(int));
       printf("\n");
       //2、定义数组时，只初始化部分数组元素，其他的默认为0
       printf("2、定义数组时，只初始化部分数组元素ages2[5] = {10 , 11};，其他的默认为0\n");
       int ages2[5] = {10 , 11};
       printArray(ages2,sizeof(ages2)/sizeof(int));
       printf("\n");
       // 3、定义数组时初始化指定下标的元素 int ages[5] = {[3] = 10, [4] = 11};
       printf("3、定义数组时初始化指定下标的元素 int ages[5] = {[3] = 10, [4] = 11};\n");
       int ages3[5] = {[3] = 10, [4] = 11};
       printArray(ages3,sizeof(ages3)/sizeof(int));
       printf("\n");
       //4、如果知道数组的大小定义数组时可以省略数组的大小 int ages[] = {10, 11, 14};
       int ages4[] = {10, 11, 14};
       printf("4、如果知道数组的大小定义数组时可以省略数组的大小 int ages[] = {10, 11, 14};\n");
       printArray(ages4,sizeof(ages4)/sizeof(int));
       printf("\n");
      // 5、使用字符或者常量或者常量的运算结果作为数组的大小 int ages[‘A‘] = {10, 11, 12, 14, 16};
       printf("使用字符或者常量或者常量的运算结果作为数组的大小 int ages[‘A‘ - 60] = {10, 11, 12, 14, 16};\n");
       int ages5[‘A‘ - 60] = {10, 11, 12, 14, 16};
       printArray(ages5,sizeof(ages5)/sizeof(int));
       printf("\n");
       //6、数组的大小使用一个变量指定，但是此时不能对数组进行初始化,如果有的数组元素没有初始化会出现不可预知的值
       printf("6、数组的大小使用一个变量指定，但是此时不能对数组进行初始化\n");
       int count = 5;
       int ages6[count];
       ages6[0] = 10;
       ages6[1] = 11;
       ages6[2] = 18;
       printArray(ages6,sizeof(ages6)/sizeof(int));
       printf("\n");
       printf("数组地址\n");
       int addr[3] = {1,2,3};
       //数组名代表数组的地址
       printf("数组addr地址是：%p\n",addr);
       printf("调用函数:\n");
       printArrayAddr(addr);
       for (int i=0; i<3; i++)
       {
           printf("数组addr[%d]的地址是：%p\n", i, &addr[i]);
       }
       printf("\n");
       int barray[2][2] = {{1,2},{3,4}};
       printf("barray的地址是:%p\n",barray);
       printf("barray[%d]的地址是:%p\n", 0, barray[0]);
       printf("barray[0][0]的地址是:%p\n", &barray[0][0]);
       printf("barray[0][1]的地址是:%p\n",&barray[0][1]);
       printf("barray[1]的地址是:%p\n",barray[1]);
       printf("barray[1][0]的地址是:%p\n",&barray[1][0]);
    return 0;
}

1、定义数组时进行初始化  int ages[5] = {10 , 11, 12, 67, 56};
array[0] = 10 
array[1] = 11 
array[2] = 12 
array[3] = 67 
array[4] = 56 

2、定义数组时，只初始化部分数组元素ages2[5] = {10 , 11};，其他的默认为0
array[0] = 10 
array[1] = 11 
array[2] = 0 
array[3] = 0 
array[4] = 0 

3、定义数组时初始化指定下标的元素 int ages[5] = {[3] = 10, [4] = 11};
array[0] = 0 
array[1] = 0 
array[2] = 0 
array[3] = 10 
array[4] = 11 

4、如果知道数组的大小定义数组时可以省略数组的大小 int ages[] = {10, 11, 14};
array[0] = 10 
array[1] = 11 
array[2] = 14 

使用字符或者常量或者常量的运算结果作为数组的大小 int ages[‘A‘ - 60] = {10, 11, 12, 14, 16};
array[0] = 10 
array[1] = 11 
array[2] = 12 
array[3] = 14 
array[4] = 16 

6、数组的大小使用一个变量指定，但是此时不能对数组进行初始化
array[0] = 10 
array[1] = 11 
array[2] = 18 
array[3] = 5 
array[4] = 4200756 

数组地址
数组addr地址是：0022fe58
调用函数:
array的地址是0022fe58 
数组addr[0]的地址是：0022fe58
数组addr[1]的地址是：0022fe5c
数组addr[2]的地址是：0022fe60

barray的地址是:0022fe48
barray[0]的地址是:0022fe48
barray[0][0]的地址是:0022fe48
barray[0][1]的地址是:0022fe4c
barray[1]的地址是:0022fe50
barray[1][0]的地址是:0022fe50