C语言从入门到入土——数组

🏠个人主页：泡泡牛奶

🌵系列专栏：C语言从入门到入土

如果想了解更多有关C语言的内容，就关注我的专栏吧😘，相信你一定能从中学到更多有意思的知识，向着目标与梦想，一起加油吧😆

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

1.1 数组的创建

Q：什么是数组 🤔？

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

Q：数组是怎样创建的 🤔？

type arr_name[const_n];
//type     是指数组的元素类型
//const_n  常量表达式，用于确定数组的大小

例如：

//代码1
int arr1[10];

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

//代码3
char arr3[10];
float arr4[10];
double arr5[10];

注： 在使用 代码2 进行数组创建的时候，要注意自己使用的编译器是否支持C99标准 ，在不支持C99标准的编译器下， [] 只能放一个常量 ，不能放变量 。而对于类似这样的数组，我们通常称之为变长数组。

1.2 数组的初始化

数组的初始化也就是指，在创建数组的同时给数组内容赋值。

例如：

int arr1[10] = { 0 };
int arr2[10] = { 1,2,3 };
int arr3[] = { 1,2,3 };

char arr4[3] = { 'a','b','c' };
char arr5[] = { 'a',98,'c' };
char arr6[] = "abcdef";

思考🤔：

1. 数组不进行初始化，数组内部是怎么样的？

2. 初始化数组时，只初始化第一位数，数组内部是怎么样的？

3. 按上方 arr6 初始化字符数组时，有几个字符？

问题1 :

数组不进行初始化，数组内部是怎么样的？

显然，如果不对数组进行初始化，数组内容全部都是不定值

问题2 :

初始化数组时，只初始化第一位数，数组内部是怎么样的？

简单的 F10 调试一下，可以看到，第一位数是初始化的值，而其余默认为0，对于这样的初始化方式，我们也称为—— 不完全初始化。

问题3 :

按上方 arr6 初始化字符数组时，有几个字符?

可以看到，使用 " " 来创建字符串时，结尾会多出一个 '\0'

1.3 一维数组的使用

在这之前，我们要请出一位老朋友 (づ￣ 3￣)づ [] 下标引用操作符。

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };//不完全初始化
    int sz = sizeof(arr) / sizeof(arr[0]);//求数组的元素个数
    int i = 0;
    //通过输入对数组进行赋值
    for (i=0; i<10; ++i)
    {
        scanf("%d", &arr[i]);
    }
    //输出数组的每个元素
    for (i=0; i<sz; ++i)
    {
        printf("%d ", arr[i]);
    }
    
    return 0;
}

小结：

• 数组通过下标访问，下标从0开始
• 数组的元素个数可以通过计算得到

2. 二维数组的创建和初始化

2.1 二维数组的创建

int arr1[3][4];
char arr2[3][4];
double arr3[][4];

在创建二维数组的时候，行可以省略，列不可以省略，即第二个[] 内必须有具体的常量表达式

2.2 二维数组的初始化

int arr1[3][4] = { 1,2,3,4 };//不完全初始化
int arr2[3][4] = { {1,2},{3,4} };
int arr3[][4] = { {1，2}，{3，4}，{5，6} }；

思考🤔：

• arr2 是怎样存储的？

不难看出，在使用 { } 对数组进行分隔时， 每一个{ }分隔都会把内部的分到不同的组

2.3 二维数组的使用

二维数组同样是通过下标来访问。

#include <stdio.h>
int main()
{ 
    int arr[3][4] = { 0 };//不完全初始化
    int i = 0;//行
    int j = 0;//列
    
    //对二维数组赋值
    for (i=0; i<3; ++i)
    {
        for (j=0; j<4; ++j)
        {
            //对二维数组赋值
            sacnf("%d", &arr[i][j]);
        }
    }
    
    for (i=0; i<3; ++i)
    {
        for (j=0; j<4; ++j)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");//换行
    }
    
    return 0;
}

3. 数组在内存中的存储

3.1 一维数组在内存中的存储

看下面一段代码😏

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i < 10; ++i)
	{
		arr[i] = i;
	}

	return 0;
}

通过调试，我们可以看到，类型为 int 的一串元素，在内存中是由低地址向高地址连续存放

3.2 二维数组在内存中的存储

我们大概知道了一维数组在内存中的存储，那么是否可以扩展一下，二维数组又是怎样存储的呢🤔？

下面，我们通过下面一串代码来看看吧😘

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

对比这两种显示方式，可以看到，二维数组同样在内存中连续存放，那我们也可以将数组看成是这样的排列方式。

那么，我们要怎样才能确定一行放几个元素呢？

这个问题，也就解释了为什么定义二维数组时，后面的数字不能缺少的原因了

4. 数组越界访问

数组的下标的范围规定是 0 ~ n-1 ，C语言本身不做对数组下标的越界检查，编译器也不会报错，但并不意味着就是正确的，

作为一个程序员，最好自己做号越界的检查

5. 数组作为函数的参数

往往我们在写代码时，会将数组作为函数参数的一部分，

例如：用函数实现一个冒泡排序 (将一个整型数组进行排序)

#include <stdio.h>

void bubble_sort(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main()
{
    int i = 0;
    int arr[] = { 1,1,4,5,1,4,1,9,1,9,8,1,0 };
    int sz = sizeof(arr)/sizeof(arr[0]);//确定数组的元素
    
    //排序
    bubble_sort(arr, sz);
    
    //打印
    for (i=0; i<sz; ++i)
    {
        printf("%d ", arr[i]);
    }
    
    return 0;
}

思考🤔

• 如果将 bubble_sort 函数改成下面这样行不行？

void bubble_sort(int arr[])
{
    int sz = sizeof(arr)/sizeof(arr[0]);
    //下面同上
}

可以看出来，若要求函数的元素个数，在函数内部是行不通的。

其原因主要是因为，**数组传参 ** 传的是 数组首元素地址，而首元素所访问到的其实就是数组第一位数了。

思考🤔

• 如果将 bubble_sort 函数改成下面这样行不行？

void bubble_sort(int arr[])
{
    int sz = sizeof(arr)/sizeof(arr[0]);
    //下面同上
}

可以看出来，若要求函数的元素个数，在函数内部是行不通的。

其原因主要是因为，数组传参 传的是 数组首元素地址，而首元素所访问到的其实就是数组第一位数了。