kiko小剧场
kiko：各位真的是好久不见，【百炼成神】专栏终于要回归了！
小明：真的是拖欠了好久哦勞···我都不打算订阅了的说。
kiko：呜呜呜，我保证，以后一周至少两更！一周两更！
小明：行叭！那就赶紧开始叭～
往期必看
【C语言百炼成神】功法一·常量与变量 【C语言百炼成神】功法二·语句与选择结构 【C语言百炼成神】功法三·循环结构
目录
知识点1：数组
1.1 一维数组
諾1.一维数组的定义
諾2.一维数组的初始化
諾3.一维数组元素的引用
典型例题1. 将一个数组逆序输出。
諾4.一维数组的地址
1.2 二维数组
諾1.二维数组的定义
諾2.二维数组的地址
諾3.二维数组的初始化
諾4.二维数组的引用
典型例题1. 将一个3*3的二维数组进行转置（行列元素互换）
知识点1：数组
Q1：什么是数组？
A1：到目前为止，我们所使用的的变量都只能存储一个数值。假如我要记录一些同学的考试分数，如果采用变量，我可能需要定义多个变量：
double score_A=99.7, score_B=65, score_c=88.5;
而数组可以用来存储一组数据类型相同的数，通过定义一个数组变量就可以处理一批类型相同的相关数据：
double score[]={99.7, 65, 88.5};
因此通过上述两类代码的对比可以发现，使用数组可以在很大程度上减少定义的变量数目，原来需要定义3个变量，使用数组后，我们仅使用score作为数组名，改变下标值，就可以表示这些变量了，比如：
printf("%d",socre[0]);//——>输出99.7
printf("%d",socre[1]);//——>输出65
printf("%d",socre[2]);//——>输出88.5
1.1 一维数组
諾1.一维数组的定义
Q1：什么是一维数组？
A1：一维数组是使用同一个数组名存储一组数据类型相同的数据，用索引或下标区分数组中的不同元素；一维数组的一般形式如下：
type_t arr_name [const_n]
type_t 是数组的元素类型。arr_name 是数组名，需要满足标识符的命名规则。const_n 是一个常量表达式，用来指定数组的大小。
因此我们通常有两种方式来定义一维数组：
//定义方式1
int age[5];
//定义方式2
#define NUM 5
int age[NUM];
关于上述数组定义的说明：
上面的两种形式都正确定义了名称为"age"的整型数组，该数组含有5个整型数据，这5个数据可以用不同的下标表示：age[0]、age[1]、age[2]、age[3]、age[4]。数组的下标是从0开始的，对于age[5]数组来说，数组元素下标的范围是0~4，而不是1~5，大于4的下标会产生数组溢出错误，下标更不能出现负数。定义数组时，age[5]括号中的数字5表示的是定义数组中元素的总数；使用数组时，age[2]=1；这条赋值语句中的方括号内的数值2是数组下标，表示的是数组中第3个元素。定义数组元素数目时，要求括号内一定要是常量，而不能是变量；在数组定义后，使用该数组的元素时，下标可以是常量、变量或表达式。
//定义数组时
int num=5;
double age[num];//×——>定义数组元素数目时使用了变量num
//使用数组时（数组已正确定义）
int main()
{
#define NUM 5
int age[NUM];//用符号常量来定义数组元素个数
int n = 0;
age[n] = 10;//使用数组时可以用变量
age[n + 1] = 20;
printf("age[0]=%d,age[1]=%d", age[n], age[n + 1]);
}
PS：关于常量与变量的更多细节和区分请见：【C语言百炼成神】功法一·常量与变量
諾2.一维数组的初始化
初始化数组是指在创建数组的同时给数组赋值，初始化数组的方式和初始化变量时的方式相同。
（1）常规的初始化
int age[5]={17, 20, 18, 30, 45};//定义整型数组，同时初始化age数组的5个元素
（2）省略的初始化
int age[ ]={17, 20, 18, 30, 45};
这里的省略指的是在定义数组时省略数组元素的个数，即改为 int age[ ] ={··}这种形式。之所以可以省略"[ ]"中的数组，是因为"{ }"中是每个数组元素的初值，即{17,20,18,30,45}是数组age中各个元素的初值，相当于变向告诉了我们数组age中有5个元素，所以可以省略"[ ]"中的5。
kiko：为了大家可以更好地理解这一种初始化的方式，我们就来举一个例子，大家可以猜猜下面这段代码的输出结果分别是什么呢？
char arr4[]="abcdef";
printf("%d\n",sizeof(arr4));
printf("%d\n",strlen(arr4));
之所以会出现这样的结果是因为字符串尾部的隐含了结束标志\0，而sizeof和strlen对于尾部\0的实际计算方法却各不相同：
sizeof运算符：sizeof求的是字符串所在内存中的长度，所以它是加上最最后的结束标志'\0'的。strlen函数：strlen 测量的是字符的实际长度，以'\0' 结束，strlen计算的结果是不加最后的结束标志'\0'。
kiko：因此sizeof计算出来的结果为7，strlen计算出来的结果为6。
（3）不完全初始化
int arr[10]={1,2,3}; //不完全初始化，剩下的元素默认初始化为0
char arr2[5]={'a',98}; //不完全初始化，剩下的元素默认为3个\0 字符里98相当于'b'
char arr5[5]={'a','b'}; //arr2与arr5相同
char arr3[5]="ab"; //这里“ab”里隐含了一个\0,因此剩余元素默认给了2个\0
不完全初始化的情况就是诸如上述这些，编译器仅对提供了的元素数值进行初始化，而其余元素编译器会为其自动进行初始化。
諾3.一维数组元素的引用
数组的特点是多个数据使用同一个变量名，利用下标引用不同数据，对此我们就需要引入一个运算符[ ] —— 下标引用运算符。
Q1：什么是下标引用运算符？
A1：下标引用运算符可以获取数组中单独的元素，它需要两个操作数。在最简单的情况下，一个操作数是一个数组名称，而另一个操作数是一个整数，例如：
age[2];//操作数age是数组名称，操作数2是一个整数。
通常情况我们可以使用循环结构控制数组下标值，进而访问不同的数组元素，这也是最常见的一种数组引用的实际案例。
#include
int main()
{
char arr[] = "abcdef";//[a][b][c][d][e][f][\0]
for (int i = 0; i < strlen(arr); i++)//strlen默认返回一个无符号整型
{
printf("%c\n", arr[i]);
}
return 0;
}
典型例题1. 将一个数组逆序输出。
满足如下要求：原数组为[1,2,3,4,5]，逆序输出为[5,4,3,2,1]。
kiko：本题的本质其实就是将数组的首尾元素进行互换，中间使用一个tmp变量作为交换，唯一需要注意的点就是在进行交换操作时for循环的判断条件，这边推荐各位可以用笔算一下，不管是奇数个元素还是偶数个元素都是这个判断条件！
int main()
{
int arr[N] = { 0 };
int i = 0;
for (i = 0; i < N; i++)
{
scanf("%d", &arr[i]);
}
printf("原数组为：");
for (i = 0; i < N; i++)
{
printf("->%d", arr[i]);
}
int tmp;
for (i = 0; i < N/2; i++)
{
tmp = arr[i];
arr[i] = arr[N - 1 - i];
arr[N - 1 - i] = tmp;
}
printf("\n转置后数组为：");
for (i = 0; i < N; i++)
{
printf("->%d", arr[i]);
}
}
諾4.一维数组的地址
数组的地址在内存中占据一块连续的存储区域，这一特点对于一维数组、二维数组、多维数组都一样适用。为了更好地进一步了解数组地址的细节，我们先来看一个典型案例：
//案例1：打印数组中的各元素地址
#include
int main()
{
int arr[10] = { 0 };
int i = 0;
for (i = 0; i < 10; i++)
{
printf("&arr[%d]=%p\n", i, &arr[i]);
}
printf("arr的首地址是=%p\n", &arr);
return 0;
}
通过上述的输出结果我们不难发现数组地址的两个特点：
数组在内存中是连续存放的：arr[1]的地址就是在arr[0]的地址基础上加上sizeof(int)个字节，即4个字节；同理arr[3]的地址就是在arr[0]的地址基础上加上3*sizeof(int)个字节，即3*4=12个字节。所以对于数组，我们只要知道了数组首地址，就可以根据偏移量计算出待求数组元素的地址。数组名就是数组的首地址，比如我们要输出数组的首地址，就可以使用下面的方式：
printf("arr的首地址是=%p\n", &arr);//数组名代表了数组首地址;&arr相当于&arr[0]
1.2 二维数组
对于处理n个学生单门课的成绩我们可以使用一维数组来解决，但如果我们现在要处理n个学生n门课的成绩时该怎么办呢？这时我们有两个办法可以进行解决：
方法一：使用n个一维数组，每个一维数组包含n个元素。方法二：直接使用一个n*n的二维数组。
kiko：显然方法二更加简单直接，通过这个例子我们便可以开始进行二维数组的学习啦！
諾1.二维数组的定义
二维数组定义的一般形式为：
类型说明符 数组名 [常量表达式][常量表达式];
因此我们可以按照上面的形式先来定义一个二维数组：
int a[3][4]; //定义数组a为3行4列的数组
a[0][0]a[0][1]a[0][2]a[0][3]a[1][0]a[1][1]a[1][2]a[1][3]a[2][0]a[2][1]a[2][2]a[2][3]
由上图二维数组的存储图可见，如果定义了数组a[3][4]，则元素下标的变化范围为：
行号范围是0~2列号范围是0~3
諾2.二维数组的地址
数组元素在内存中占用一块连续的存储区域，一维数组的内存地址是按照下标的顺序排列存储的，如下图所示。
int a[3][4]; //定义数组a为3行4列的数组
二维数组的存储方式则是按行存储的，每个整型元素占sizeof(int)个字节，即4个字节。先依次保存第一行所有元素，再依次保存第二行所有元素，···，直到所有行元素全部保存完毕。
a[0][0]a[0][1] a[0][2] a[1][0]·····
Q1：已知a[0][0]在内存中的地址，a[1][0]的地址是多少呢？
A1：二维数组的计算方法其实与一维数组大同小异，也是通过计算首地址+偏移量来计算最终结果的，其计算方法如下：
a[1][1]的地址=a[0][0]地址+4*4字节
4*4字节=(第1行*3列+第2行*1列)*单个元素所占字节
对此我们同样可以举一个例子来进行验证：
#include
int main()
{
int arr[][4]={{1,2},{3,4},{5,6}};
int i=0;
int 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]);
}
printf("\n");
}
return 0;
}
通过这个输出我们也可以明显的发现a[1][0]的存储地址就位于a[0][3]之后，这也间接证明了二维数组的存储方式是先存储完一行元素，再紧接着存储后边一行元素。
諾3.二维数组的初始化
二维数组的初始化原理同一维数组相同，因此我也将其分为以下三类：
（1）常见的初始化
int a[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
由于二维数组在内存中是按照线性顺序存储的，因此行括号可以省去，进而就可以这样定义：
int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
（2）省略的初始化
int a[][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
or
int a[][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
我们可以对行进行省略，但是不能对列进行省略，例如上述程序就可将[ ]中的3省略，但是列数[4]不能省去。
Q1：为什么可以省去行数，不能省去列数呢？
A1：这是因为编译器会根据所赋数值的个数以及数组的列数，自动计算出数组的行数；例如上边告知编译器二维数组的列数为4，所附数值的个数为12个，那么它就可以按每1行4列来配置元素，自然配置完12个元素后就可以计算得出行数为3。
但如果告诉编译器行数，不告诉列数的话，即定义为a[3][ ]，编译器可不想我们人类这么聪明，在脑海里进行除法，因为编译器当时是不知道赋值个数有多少，因此它就不知道在一行可以分配多少个元素，所以会产生报错的情况！
（3）不完全初始化
//情况1：不包含{}
int arr1[3][4]={1,2,3,4,5,6,7};//不完全初始化--后面补零
这种不完全初始化方式中没有使用{ }，因此在arr1中，编译器会按顺序将这些元素赋值到二维数组中，也就是从a[0][0]开始一直赋值到a[1][2]，二维数组中剩下的位置补0。
//情况2：包含{}
int arr2[3][4]={{1,2},{3,4},{5,6}};
int arr3[][4]={{1,2},{3,4},{5,6}};
在这种情况下，由于在定义二维数组的过程中使用了{ }进而确定了每一行的元素个数，因此将按{ }确定的格式进行赋值，在二维数组中剩下的位置补0。
諾4.二维数组的引用
二维数组元素的操作和一维数组基本相同，通常我们会使用双重循环的方式来遍历数组元素，用外层循环控制数组的行标，用内层循环控制数组的列标，通常的引用方式如下：
···
for (i = 0; i < 3; i++) //控制行标
{
for (j = 0; j < 4; j++) //控制列标
{
arr[i][j] = i + j;
}
}
典型例题1. 将一个3*3的二维数组进行转置（行列元素互换）
kiko：这一道例题用极为基础的语言来进行二维数组的重复，使用双层循环来进行二维数组的调取，同理如果是三维数组，就使用三层循环，希望大家可以简单处理一下这道题，各位可以把自己的题解发在评论区哦！后期可能会加入到本文中滴！
#include
#define LIN 2 //使用宏常量是为了后期可以方便更改矩阵的大小
#define COL 2
int main()
{
int arr1[LIN][COL] = { 0 };
int arr2[LIN][COL] = { 0 };
int i = 0;
printf("请输入2*2数组的元素：\n");
for (i = 0; i < LIN; i++)
{
for (int j = 0; j < COL; j++)
{
scanf("%d", &arr1[i][j]);//输入2*2的数组
}
}
for (i = 0; i < LIN; i++)
{
for (int j = 0; j < COL; j++)
{
printf("%d\t", arr1[i][j]);//打印一遍输入的2*2数组
}
printf("\n");
}
for (i = 0; i < LIN; i++)
{
for (int j = 0; j < COL; j++)
{
arr2[j][i] = arr1[i][j];//进行数组转置
}
}
printf("转置后的数组为：\n");
for (i = 0; i < LIN; i++)
{
for (int j = 0; j < COL; j++)
{
printf("%d\t", arr2[i][j]);//输出转置后的数组
}
printf("\n");
}
}
参考链接
您阅读本篇文章共花了：
发表评论