C语言_数组知识总结

数组

知识重点：

1、一维数组的创建和初始化

2、一维数组的使用

3、一维数组在内存中的存储

4、指针的初步介绍

5、一维数组的指针访问

6、二维数组的创建和初始化

7、二维数组的使用

8、二维数组在内存中的存储

正文

一、一维数组的创建和初始化

1、数组的创建：

数组：是一组相同类型元素的集合

数组的创建方式：

    type_t arr_name [const_n];
    //type_t  是指数组的元素类型
    //const_n  是一个常量表达式用来指定数组的大小

数组创建实例：

    //代码1：
    int arr1[10];

错误示范：

    //代码2：
    int coumt = 10;
    int arr2[count]

注：

数组创建时[ ]中要给一个常量才可以，不能使用变量

2、数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理的值，例如：

    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[] = "abcdef";

数组在创建的时候如果不想指定数组的大小就要初始化，数组的元素个数根据初始化的内容来确定

但是对于下面的代码要注意区分其在内存中的分配：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char arr1[] = "abc";
    char arr2[5] = {'a', 'b', 'c', '\0'};
    char *p = "abcdef";
    char arr3[3] = {'a', 'b', 'c'};
    int i = 0, j = 0, k = 0, l = 0;

    i = strlen (arr1);
    j = strlen (arr2);
    k = strlen (p);
    l = strlen (arr3);

    printf ("%d  %d  %d  %d\n",i, j, k, l);

    system ("pause");
    return 0;
}
/*
运行结果：

3  3  6  15
请按任意键继续. . .

*/

注意：上面代码中的 char arr3[3] = {‘a’, ‘b’, ‘c’};之所以会出现运行结果是15，是因为数组越界了，像这种字符数组最后必须多留一个给’\0’标识数组结束。

二、一维数组的使用

对于数组的使用：之前在操作符知识总结中也提到一个操作符 :[ ],下标引用操作符，它其实就是数组访问的操作符。代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
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]);
    }

    system ("pause");
    return 0;
}

/*
运行结果：
0  1  2  3  4  5  6  7  8  9  请按任意键继续. . .
*/

总结：

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

（2）数组的大小可通过计算得到,代码如下：

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

三、一维数组在内存中的存储

通过下面一段代码来看以为数组在内存中的存储

#include <stdio.h>
#include <stdlib.h>
#include <string.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]);
    }

    system ("pause");
    return 0;
}
/*
运行结果：
&arr[0] = 00AFFEA4
&arr[1] = 00AFFEA8
&arr[2] = 00AFFEAC
&arr[3] = 00AFFEB0
&arr[4] = 00AFFEB4
&arr[5] = 00AFFEB8
&arr[6] = 00AFFEBC
&arr[7] = 00AFFEC0
&arr[8] = 00AFFEC4
&arr[9] = 00AFFEC8
请按任意键继续. . .
*/

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

四、指针的初步介绍

上面我们已经知道了数组在内存中的存储方式，现在可以尝试使用指正的形式访问数组，首先使用一下指针。

为了很好的管理内存，我们首先对内存进行一个详细的编址。

结论：

（1）内存中的每个内存单元（字节）对应每个地址。

（2）在32位平台上指针大小是4个字节，在64位平台上是8个字节，所以我们在C语言中提取某个变量的地址：

    int n = 10;
    &n;//取出n的地址

指针可以理解为一个变量，是一个专门用来存放地址的变量。

通常我们将的指针其实是一个指针变量。

接下来看看指针变量的定义：

    int *ptr = NULL;//定义一个整形指针变量，初始化为NULL
    char *ptr = NULL;//定义一个字符型指针变量，初始化为NULL
    double *ptr = NULL;//定义一个双精度浮点数指针变量，初始化为NULL

当我们拿到一个指针时也要能找到指针所指向的变量，其中 * 是解引用操作符。

int n = 10;
int *p_n = &n;将num的地址存放在p_n指针变量中。
*p_n = 20;//改变的其实是n这个变量的内容。

五、一维数组的指针访问

首先我们先看这一段代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{

    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

    printf ("%p\n",arr);
    printf ("%d\n",*arr);

    system ("pause");
    return 0;
}
/*
运行结果：
0053FC58
1
请按任意键继续. . .
*/

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

在看下面的代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int arr[10] = {0};
    int i = 0;
    for (i=0; i<sizeof(arr)/sizeof (arr[0]); ++i)
    {
        printf ("&arr[%d] = %p\t", i, &arr[i]);
        printf ("%p\n",arr+i);
    }
    system ("pause");
    return 0;
}
/*
运行结果：
&arr[0] = 00CFF964      00CFF964
&arr[1] = 00CFF968      00CFF968
&arr[2] = 00CFF96C      00CFF96C
&arr[3] = 00CFF970      00CFF970
&arr[4] = 00CFF974      00CFF974
&arr[5] = 00CFF978      00CFF978
&arr[6] = 00CFF97C      00CFF97C
&arr[7] = 00CFF980      00CFF980
&arr[8] = 00CFF984      00CFF984
&arr[9] = 00CFF988      00CFF988
请按任意键继续. . .
*/

由此可见：通过数组名加整数的运算就可以得到数组的每个元素的地址

* 因此我们就可以用指针来访问数组了：

#include <stdio.h>
#include <stdlib.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 ",*(p_arr+i));
    }
    system ("pause");
    return 0;
}
/*
运行结果：
0 1 2 3 4 5 6 7 8 9 请按任意键继续. . .
*/

六、二维数组的创建和初始化

1、二维数组的创建和初始化

    //二维数组的创建
    int arr1[3][4];
    char arr2[3][5];
    double arr3[2][4];

    //二维数组的初始化
    int arr1[3][4] = {1, 2, 3, 4};
    int arr2[3][4] = {{1, 2}, {4, 5}};
    int arr2[][4] = {{3, 2}, {4, 5}};

七、二维数组的使用

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

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int arr[3][4] = {0};
    int i = 0, j = 0;
    for (i=0; i<3; i++)
    {
        for(j=0; j<4; ++j)
        {
            arr[i][j] = i*4+j;
        }
    }
    for (i=0; i<3; i++)
    {
        for(j=0; j<4; ++j)
        {
            printf ("%d ",arr[i][j]);
        }
    }
    system ("pause");
    return 0;
}
/*
运行结果：
0 1 2 3 4 5 6 7 8 9 10 11 请按任意键继续. . .
*/

八、二维数组在内存中的存储

像一维数组一样，我们尝试打印二维数组的每个元素地址

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int arr[3][4] = {0};
    int i = 0, j = 0;
    for (i=0; i<3; i++)
    {
        for(j=0; j<4; ++j)
        {
            printf("&arr[%d][%d] = %p\n",i, j, &arr[i][j]);
        }
    }
    system ("pause");
    return 0;
}
/*
运行结果：
&arr[0][0] = 0073FDCC
&arr[0][1] = 0073FDD0
&arr[0][2] = 0073FDD4
&arr[0][3] = 0073FDD8
&arr[1][0] = 0073FDDC
&arr[1][1] = 0073FDE0
&arr[1][2] = 0073FDE4
&arr[1][3] = 0073FDE8
&arr[2][0] = 0073FDEC
&arr[2][1] = 0073FDF0
&arr[2][2] = 0073FDF4
&arr[2][3] = 0073FDF8
请按任意键继续. . .
*/

由此可见：二维数组在内存中也是连续存储的，如下图：