C语言数组知识点总结

数组：就是只能存放一种数据类型，比如int类型的数组、float类型的数组，里面存放的数据称为“元素”

数组的定义：

首先声明数组的类型，然后声明数组元素的个数（也就是需要多少存储空间）

格式： 元素类型 数组名[元素个数];

 比如： int[3];

数组元素有顺序之分，每个元素都有一个唯一的下标（索引），而且都是从0开始

数组元素的访问: a[i]

数组元素的初始化：

 int a[3] = {10, 9, 6};

 int a[3] = {10,9};

 int a[] = {11, 7, 6};

 int a[4] = {[1]=11,[0] = 7};

#include<stdio.h>

int main()
{
    //数组的定义格式： 类型 变量名[元素个数];
    //int ages[5];
    
    //数组的赋值方式：
    /*
    ages[0] = 12;
    ages[1] = 19;
    ages[2] = 14;
    ages[3] = 26;
    ages[4] = 18;
     */
    
    //int ages[5] = {[2] = 14,[3] = 26};
    //int ages[5] = {12,19};
    int ages[5] = {12,19,14,26,18};
    
    //错误写法：
    //int ages[];
    //错误写法
    //int ages[5];     只能在定义数组的时候进行初始化
    //ages = {12,19,14,26,18};
    //错误写法,如果想在定义数组的同时进行初始化，数组元素个数必须是常量或者不写
    //int ages[count] = {12,19,14,26,18};
    
    /*数组的遍历，按顺序查看数组的每一个元素*/
    
    //1.for循环遍历
    for (int i = 0; i <5; i++)
    {
        printf("ages[%d] = %d
",i ,ages[i]);
    }
    
    
    
    return 0;
}

[ ]里面的个数必须是一个固定值，可以是常量(比如6、8)、常量表达式(比如3+4、5*7)。绝对不能使用变量或者变量表达式来表示元素个数，大多数情况下不要省略元素个数

（当数组作为函数的形参和数组初始化时除外）

C语言中编译器是不会对数组下标越界进行检查的，所以自己访问数组元素时要注意

数组的内存细节分析：

#include<stdio.h>

int main()
{
    char cs[5] = {"a","A","D","e","f"};
    
    printf("%p
",cs);  // 数组名就代表数组的地址
    
    for (int i = 0; i<5; i++)
    {
        printf("cs[%d]的地址是:%p
",i ,&cs[i]);
    }
    
    return 0;
}

地址分配分析如下：

一维数组与函数参数：

  一维数组的元素作为函数实参，与同类型的简单变量作为实参一样，是单向的值传递，即数组元素的值传给形参，从而形参是改变不影响实参

数组名代表着整个数组的地址，如果一维数组的名字作为函数实参，传递的是整个数组，即形参数组和实参数组完全相同，是存放在同一存储空间的同一个数组。这样形参数组

修改时，实参数组也同时被修改了。形参数组的元素个数可以省略。

// b是test函数的形参(形式参数)
void test(int b) {
    b = 9;
}

int main()
{
    int a[3];
    a[0] = 10;
    
    printf("函数调用前的a[0]：%d
", a[0]);
    
    test(a[0]); // a[0]是test函数的实参(实际参数)

    printf("函数调用后的a[0]：%d", a[0]);
    return 0;
}

#include<stdio.h>

//数组作为函数参数，可以省略元素个数
//数组作为函数参数，传递是整个数组的地址，修改了函数形参数组元素的值，会影响到外面的实参数组
void change(int array[])
{
    printf("array ==%p
",array);
    
    array[0] = 100;
}

int main()
{
    int ages[6] = {10,11,13,15,11,18};
    
    printf("array ==%p
",ages);
    
    change(ages);
    
    printf("%d
",ages[0]);
    
    return 0;
    
}

输出结果为：  array ==0x7fff5be26c00
            array ==0x7fff5be26c00
            100

数组的小练习：

/*
设计一个函数，找出整型数组元素的最大值
*/

#include <stdio.h>

int maxOfArray(<span style="color:#ff0000;">int array[], int length</span>)
{
    <span style="color:#ff0000;">// 数组当做函数参数传递时，会当做指针变量来使用，指针变量在64bit编译器环境下，占据8个字节</span>
    
    //int size = sizeof(array);
    //printf("array=%d
", size);
    
    //sizeof(array);
    
    // 1.定义一个变量存储最大值(默认就是首元素)
    int max = array[0];
    
    // 2.遍历所有元素，找出最大值
    for (int i = 1; i<length; i++)
    {
        // 如果当前元素大于max，就用当前元素覆盖max
        if (array[i] > max)
        {
            max = array[i];
        }
    }
    
    return max;
}

int main()
{
    int ages[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    int ages2[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    //int size = sizeof(ages);
    
    //printf("ages=%d
", size);
    int max = maxOfArray(ages, <span style="color:#ff0000;">sizeof(ages)/sizeof(int)</span>);
    
    printf("%d
", max);
    return 0;
}

二维数组的定义：

一个数组能表示一个班人的年龄，如果想表示很多班呢？

什么是二维数组？int ages[3][10]; 三个班，每个班10个人，相当于3行10列，相当于装着3个一维数组

二维数组是一个特殊的一维数组：它的元素是一维数组。例如int a[2][3]可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素

定义形式： 类型  数组名[ 行数] [列数]

int  a[2][3];   //2行3列的二维数组

二维数组的存放顺序是按行存放的，先存放第一行的元素，再存放第2行的元素。例如int a[2][3]的存放顺序是：a[0][0] → a[0][1] → a[0][2] → a[1][0] → a[1][1] → a[1][2]

二维数组的内存存储分配：

(注意：a[0]、a[1]也是数组，是一维数组，而且a[0]、a[1]就是数组名，因此a[0]、a[1]就代表着这个一维数组的地址)

1> 数组a的地址是ffc1，数组a[0]的地址也是ffc1，即a = a[0]；

2> 元素a[0][0]的地址是ffc1，所以数组a[0]的地址和元素a[0][0]的地址相同，即a[0] = &a[0][0]；

3> 最终可以得出结论：a = a[0] = &a[0][0]，以此类推，可以得出a[1] = &a[1][0]

二维数组的初始化：

int a[3][4] = {1,2,3,4,5,6};

int a[3][4] = {{},{},{}};

int main()
{
    /*
    int ages[5] = {10, 11, 90, 89, 70};
    
    int ages2[3][5]= {
        {10, 11, 90, 89, 70},
        
        {10, 11, 90, 89, 70},
        
        {10, 11, 90, 89, 70}
    };*/
    char cs[2][3];
    
    /*
     1 浅蓝色
     2 深蓝色
     3 黄色
     4 红色
     -1 没有
     */
    
    int cubes[5][5] = {
        {1, -1, -1, -1, -1},
        {1, 1, -1, 2, -1},
        {4, 1, 2, 2, 2},
        {4, 3, 3, 3, 3},
        {4, 3, 3, 3, 3}
    };
    
    /*
     1 白色
     2 黑色
     -1 没有
     */
    int wuzi[6][6] = {
        {};
    };
    
    
    return 0;<strong>
</strong>