本文围绕数组展开，介绍了数组是内存中连续的相同类型变量空间，属于构造数据类型。详细阐述了一维、二维、多维数组的定义、初始化、大小计算和内存存储，还提及字符数组与字符串的区别、输入输出方法，包含强化训练案例。
文章目录
1 数组概述
数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。
数组属于构造数据类型：由基本数据类型构成的集合
构造数据类型（两种）：
数组：相同类型的数据存放的集合
结构体：不同数据类型放在集合中
数组的分类：
按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。
int a[10]; char s[10]; char *p[10];
通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。
2 一维数组
2.1 数组的定义
int main()
{
//数组名和变量名定义方法一样
//符号与[]结合代表这个是一个数组
//数组中的元素的个数由[]里面的数值决定
//每个元素的类型,数组名前面的类型决定
//定义数组时,[]里面的值不能为变量,只能为常量
//使用时,[]里面的值可以为常量也可以是变量
//数值数组不能整体操作
//数组的每一个元素都是变量,可以被改变赋值
int n = 10;
int num[10];
//num[0] = 100;
//printf("%d\n",num[0]);
for (int i = 0; i < 10; i++)
{
printf("%d\n", num[i]);
}
system("pause");
return 0;
}
2.2 数组的初始化
//数组的初始化
int main()
{
//int num[10] = {1,2,3,4,5,6,7,8,9,10};
//如果数组只初始化部分元素,其他元素被初始化为0
//int num[10] = { 1,2 };
//int num[10] = { 0 };//将数组所有元素初始化为0
//int num[10] = {[5]=5};
//int num[]; err 定义时没有告知有几个元素
int num[] = { 1,2,3 };//如果定义时,[]中没有值,这个数组的元素个数由{}里面的元素个数决定
for (int i = 0; i < 10; i++)
{
printf("%d ", num[i]);
}
printf("\n");
system("pause");
return 0;
}
2.3 数组的大小
数组的大小：sizeof(num)
数组的元素个数：sizeof(num) / sizeof(num[0])
//数组的大小
int main()
{
//num是数组名,代表这个数组
int num[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n",sizeof(int [10]));
printf("%d\n", sizeof(num));
//求数组元素个数
int n = sizeof(num) / sizeof(num[0]);
printf("n=%d\n",n);
for (int i = 0; i < sizeof(num)/sizeof(num[0]); i++)
{
printf("%d ", num[i]);
}
system("pause");
return 0;
}
2.4 数组在内存中的存储
int main()
{
int a[5];
printf("%u\n",&a[0]);
printf("%u\n", a);
printf("%u\n", &a);
printf("%u\n", &a[0]+1);
printf("%u\n", a+1);
printf("%u\n", &a+1);
system("pause");
return 0;
}
2.5 强化训练
1 求数组的最值
2 逆序数组
3 冒泡排序
//冒泡排序
int main()
{
int a[] = {1,2,5,3,2,9,2,1,28};
int n = sizeof(a) / sizeof(a[0]);
//n个数比较n-1轮
for (int i = 0; i < n-1; i++)
{
//每轮的比较，两两比较,每次从起始0下标冒泡到待比较数（用轮数来表示待比较数）
//这里利用规律 轮数与待比较的数的下标关系：j = n-1-i
//第1轮， 从0冒泡到n-2：两两比较n-2 和 n-1能比到结尾
for (int j = 0; j < n-1-i; j++)
{
if (a[j] > a[j + 1])
{
int tmp = a[j + 1];
a[j + 1] = a[j];
a[j] = tmp;
}
}
}
}
3 二维数组
二维数组：两个一维数组
在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。
3.1 二维数组的定义和使用
int a[3][4];
命名规则同一维数组
定义了一个三行四列的数组，数组名为a其元素类型为整型，该数组的元素个数为3×4个，即：
二维数组a是按行进行存放的，先存放a[0]行，再存放a[1]行、a[2]行，并且每行有四个元素，也是依次存放的。
int main()
{
int a[3][4];//定义一个3行4列的二维数组,
//二维数组的每一个元素也是一个 变量
a[1][1] = 10;
a[2][3] = 20;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%d ",a[i][j]);
}
printf("\n");
}
system("pause");
return 0;
}
3.2 二维数组的初始化
int main()
{
//给二维数组部分元素初始化,其他元素为0
//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 };
//int a[3][4] = {1,2,3};
//二维数组定义时,不能省略列的下标,可以省略行的下标
int a[][3] = { 1,2,3,4,5 };
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
system("pause");
return 0;
}
3.3 二维数组的大小
求二维数组的元素个数，行和列
sizeof(a)：总大小
sizeof(a[0])：第一行的大小
sizeof(a[0][0])：一个元素的大小
int main()
{
int a[3][4] = {1,2,3};
int n = sizeof(a) / sizeof(a[0][0]);//元素的个数
int line = sizeof(a) / sizeof(a[0]);//行数 = 二维数组总大小除以 一行的大小
int clu = sizeof(a[0]) / sizeof(a[0][0]);//列 = 行大小除以 一个元素的大小
printf("%d %d %d\n",n,line,clu);
system("pause");
return 0;
}
3.4 二维数组在内存中的存储
一维数组的数组名代表首个元素的地址
二维数组的数组名代表首行元素的地址
总结：
二维数组：数组名a[0]
一维数组：数组名a
二维数组：&a[0] + 1：跨过整行
一维数组：&a：跨过整个一维数组
二维数组：&a[0][0]代表一个元素地址 等于 二维数组的a[0]
解释：二维数组的a[0]代表二维数组首行的数组名，代表首个元素的地址
类比于一维数组中数组名a代表首个元素的地址
tips：
二维数组：a表示首行元素地址
一维数组：a表示首个元素地址
tips：
a[0]代表第0行 == 第0行数组名 a[0]+1跳过一个元素
&a[0]代表第0行的地址 &a[0] + 1跳过一行
3.5 强化训练
案例一：
#include <stdio.h>
int main()
{
//二维数组： 五行、三列
//行代表人： 老大到老五
//列代表科目：语、数、外
float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };
int i, j, person_low[3] = { 0 };
float s = 0, lesson_aver[3] = { 0 };
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
s = s + a[j][i];
if (a[j][i] < 60)
{
person_low[i]++;
}
}
lesson_aver[i] = s / 5;
s = 0;
}
printf("各科的平均成绩:\n");
for (i = 0; i < 3; i++)
{
printf("%.2f\n", lesson_aver[i]);
}
printf("各科不及格的人数:\n");
for (i = 0; i < 3; i++)
{
printf("%d\n", person_low[i]);
}
return 0;
}
4 多维数组
int num[2][3][4]
定义了一个三维数组：
有2个二维数组
每个二维数组有3个一维数组
每个一维数组有4个元素
三维数组初始化
int num[2][3][4]={
{
{1,2,3,4},{5,6,7,8},{8.8.9.0}
},
{
{0,2,3,4},{5,6,7,8},{8.8.9.0}
},
};
打印三维数组:
for(int i =0;i<2;i++)
{
for(int j=0;j<3;j++)
{
for(int k=0;k<4;k++)
{}
}
}
5 字符数组与字符串
5.1 字符数组与字符串区别
- C语言中没有字符串这种数据类型，可以通过char的数组来替代；
- 字符串一定是一个char的数组，但char的数组未必是字符串；
- 数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。
5.2 字符数组
int a[10]//每个元素int类型,所以这个是数值数组
char a[10]//每个元素是char类型,所以这个是字符数组
int main()
{
//"hello"
//字符数组
//字符串就是字符数组中有\0字符的数组
//因为有\0字符的字符数组,操作起来方便
//char a[5] = {'a','b','c','d','e'};普通的字符数组
//char a[5] = {'a','b','c','d','\0'};//字符数组中含有\0字符的,它也是字符串
//char a[5] = "abcd";//定义了一个字符数组,存的是abcd\0
//char a[] = "world";//此字符数组共有6个元素
//char a[100] = "abcd";//定义了一个字符数组,有100个元素
//char a[100] = "\0";//将数组的第0个元素填\0,其他元素就是\0
char a[100] = { 0 };//将一个字符数组清0
/*for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
printf("%c",a[i]);
}*/
printf("%s\n",a);
printf("\n");
printf("%s\n","hello");
system("pause");
return 0;
}
案例一：
#include <stdio.h>
int main()
{
char c1[] = { 'c', ' ', 'p', 'r', 'o', 'g' }; //普通字符数组
printf("c1 = %s\n", c1); //乱码，因为没有’\0’结束符，c1表示起始地址，然后往后一直输出直到0结束
//以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
char c2[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0'};
printf("c2 = %s\n", c2);
//字符串处理以‘\0’(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出
char c3[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
printf("c3 = %s\n", c3);
return 0;
}
5.3 字符串初始化
#include <stdio.h>
// C语言没有字符串类型，通过字符数组模拟
// C语言字符串，以字符‘\0’, 数字0
int main()
{
//不指定长度, 没有0结束符，有多少个元素就有多长
char buf[] = { 'a', 'b', 'c' };
printf("buf = %s\n", buf); //乱码，一直没有碰到\0，访问到别的内存了
//指定长度，后面没有赋值的元素，自动补0
char buf2[100] = { 'a', 'b', 'c' };
char buf[1000]={“hello”};
printf("buf2 = %s\n", buf2);
//所有元素赋值为0
char buf3[100] = { 0 };
//char buf4[2] = { '1', '2', '3' };//数组越界
char buf5[50] = { '1', 'a', 'b', '0', '7' };
printf("buf5 = %s\n", buf5);
char buf6[50] = { '1', 'a', 'b', 0, '7' };
printf("buf6 = %s\n", buf6);
char buf7[50] = { '1', 'a', 'b', '\0', '7' };
printf("buf7 = %s\n", buf7);
//使用字符串初始化，编译器自动在后面补0，常用
char buf8[] = "agjdslgjlsdjg";
//'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
//'\ddd'八进制字义字符，'\xdd'十六进制转移字符
// \012相当于\n
char str[] = "\012abc";
printf("str == %s\n", str);
return 0;
}
5.4 字符串的输入
1 scanf
缺点：
1 提前限制字符数组大小，输入超过长度，会内存污染
2 不能读取有空格的字符串
int main()
{
char ch = 0;
//scanf("%c",&ch); 从键盘读取一个字符
//读取一个字符串
char num[128] = "";
//%s从键盘获取一个字符串,遇到\n结束
scanf("%s",num);
//%s 要的是打印字符数组的首元素地址
printf("[%s]\n",num);
system("pause");
return 0;
}
2 gets
gets是一个库函数,从键盘读取字符串
解决了：
1 可以读取有空格的字符串，
缺点：
2 但是限制了长度，也会内存污染
int main()
{
//gets遇到\n结束.,但是遇到空格不结束读取空格
//gets也会造成内存污染
char num[5] = "";
gets(num);//()里面的参数要的是存放读取字符串的地址
printf("num=%s\n",num);
system("pause");
return 0;
}
3 fgets
库函数: 从键盘读取一个字符串
char num[128];
fgets( num, sizeof(num) ,stdin );
num：读入的起始地址
sizeof(num)：最大可以读取字节数：超过末尾自动添加\0，截取字符串，不会内存污染。
stdin: 标准输入文件：从标准输入文件中读
int main()
{
//fgets会把回车键\n读取
char buf[1024] = "";
fgets(buf,sizeof(buf),stdin);//hello\n
printf("%s\n",buf);
system("pause");
return 0;
}
解决：
fgets 相对于scanf 和 gets不会污染内存,(安全)
缺点：
但是fgets会将\n读取
解决办法：
将最后一位字符的\n 置为 \0
最后一位字符的下标：即：字符串的长度-1
strlen
库函数:strlen
作用: 测字符数组字符的个数
strlen(),()中的参数要的是字符数组的首元素地址
int main()
{
char buf[128] = "helloA";//buf[5]=0;
//需要找到最后一个字符的下标
//求的是字符数组有效字符的个数
int i = 0;
/*while (buf[i] != '\0')
{
i++;
}
printf("i=%d\n",i);*/
i = strlen(buf);//strlen()测字符数组有效字符的个数
printf("i=%d\n", i);
buf[i - 1] = '\0';
printf("%s\n",buf);
system("pause");
return 0;
}
4 最终采用的输入
fgets + strlen
int main()
{
char buf[128] = {0};
fgets(buf,sizeof(buf),stdin);
buf[strlen(buf) - 1] = '\0';
printf("%s\n",buf);
system("pause");
return 0;
}
5.5 字符串的输出
1 printf
2 puts
3 fputs
int main()
{
char buf[1024] = "helloworld";
//printf("%s\n",buf);
//puts(buf);//数组首元素地址,有换行
fputs(buf,stdout);//第一个参数,数组首元素地址,stdout标准输出(屏幕)
system("pause");
return 0;
}
扫一扫
1710
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
