初步解析数组

一维数组的创建

type_t   arr _name[const_n]; 
    //type_t 数组类型
    //arr_name 数组名称
    //const_n 数组维度,必须放常量

注意: 声明时,如果数组内没有确定的元素必须设置数组维度.

    int arr1[10];

    int count = 10;
    int arr2[count];
    //错误,count为变量不能放在[]中
    const int count = 10;
    int arr2[count];
    //在c语言中无法编译,证明count不是一个常量

    char arr3[10];
    float arr4[1];
    double arr5[10];

    //数组初始化
    int arr1[10] = { 1, 2, 3 };
    int arr2[] = { 1, 2, 3, 4 };
    int arr3[5] = { 1,2,3,4,5 };
    char arr4[3] = { 'a', 98, 'c' };

    char arr5[] = { 'a', 'b', 'c' };
    //若初始化时未设置数组维度,数组大小由元素个数决定
    char arr6[] = "abcdef";//c风格字符串
    char* p = "abcdef";
    //arr5中元素:'a','b','c'
    //arr6中元素:'a','b''c''\0'
    //p是字符a的地址

---

一维数组的使用

数组是使用下标来访问的，下标是从0开始

int main()
 {
    int arr[10] = { 0 };//数组的不完全初始化。
     //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
     int i = 0;//做下标
     for (i = 0; i<10; i++)
     {
         arr[i] = i;
     }
     //输出数组的内容
     for (i = 0; i<10; ++i)
     {
         printf("%d ", arr[i]);
     }
     return 0;
}

数组的大小可以通过计算得到

int arr[10];
int sz = sizeof(arr) / sizeof(arr[0]);

注意:数组名表示整个数组的地址只有两种情况:
1.sizeof(arr) 括号内没有其他任何符号
2.&arr
其余情况表示数组首元素地址.
因此在函数内部不可用sizeof求取数组维度,因为传参时无法传入整个数组的地址.

void bubble_sort(int arr[])
{
    int sz = sizeof(arr)/sizeof(arr[0]);
    ...
}

这样应该是错误的。
数组作为函数参数的时候，不会把整个数组的传递过去。实际上只是把数组的首元素的
地址传递过去了。所以即使在函数参数部分写成数组的形式：
int arr[] 表示的依然是一个指针： int *arr 。
上面代码中的sz最后的值应该是1，而不是数组元素的个数。

---

一维数组在内存中的存储

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int i = 0;
    for(i=0; i<sizeof(arr)/sizeof(arr[0]); ++i)
    {
    printf("&arr[%d] = %p\n", i, &arr[i]);
    }
    return 0;
}

随着数组下标的增长，元素的地址，也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的。

---

一维数组的指针访问

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    printf("%p\n", arr);//输出结果:006efeb8
    printf("%d\n", *arr);//输出结果:1
    return 0;
}

由此可见，数组的数组名其实是数组首元素的地址。

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int i = 0;
    int *p_arr = arr;
    for(i=0; i<sizeof(arr)/sizeof(arr[0]); ++i)
    {
        *(p_arr+i) = i;
    }
    for(i=0; i<sizeof(arr)/sizeof(arr[0]); ++i)
    {
        printf("%d\n", *(p_arr+i));//
    }
    return 0;
}

观察结果我们发现，通过对数组名+整数的运算，其实可以获取到数组每个元素的地址。

---

二维数组的创建和初始化

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];
//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};

二维数组的使用也是通过下标的方式。

#include <stdio.h>
int main()
{
    int arr[3][4] = {0};
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
        arr[i][j] = i*4+j;
        }
    }
    for(i=0; i<3; i++)
    {
            int j = 0;
        for(j=0; j<4; j++)
        {
        printf("%d ", arr[i][j]);
        }
    }
    return 0;
}

运行结果

---

二维数组在内存中的存储
像一维数组一样，这里我们尝试打印二维数组的每个元素。

#include <stdio.h>
int main()
{
    int arr[3][4];
    int i = 0;
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
        }
    }
     return 0;
}

运行结果

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

二维数组其实是数组的数组.
当一个数组的元素仍然是数组时,通常使用两个维度来定义它:一个维度表示本身大小,另一个维度表示其元素(也是数组)大小.
常把第一个维度称为行,第二个维度称为列.

---

二维数组的指针访问
知道了一维数组的内存存储模式之后，尝试使用指针对一维数组的访问。那这里
尝试使用指针来访问我们的二维数组。

#include <stdio.h>
int main()
{
    int arr[3][4] = {0};
    int *p = &arr[0][0];
    int i = 0;
    for(i=0; i<3*4; i++)
    {
        p[i] = i;
    }
    for(i=0; i<3; i++)
    {
        int j = 0;
        for(j=0; j<4; j++)
        {
            printf("%d ", arr[i][j]);
        }
    }
    return 0;
}

输出结果依然是

---

另:
二维数组传参,数组名作为形参

void func1(int iArray[][10])  
{  
  ;
}  
int main()  
{  
    int array[10][10];  
    func1(array); 
}  

形参声明一定要给出第二个维度的大小.