第四章数组（预习笔记）

at0527

已于 2023-01-11 16:55:50 修改

阅读量182

点赞数

分类专栏：初级C语言课程-课堂笔记文章标签：算法数据结构 c语言

于 2023-01-04 17:43:48 首次发布

本文链接：https://blog.csdn.net/at0527/article/details/128547319

版权

初级C语言课程-课堂笔记专栏收录该内容

33 篇文章 0 订阅

订阅专栏

文章详细介绍了C语言中一维数组的定义、初始化、使用以及在内存中的存储方式，包括数组的下标访问和地址表示。接着讨论了二维数组的创建、初始化和内存布局。此外，还提到了数组越界的问题和将数组作为函数参数时的注意事项。最后，通过冒泡排序函数展示了数组在实际操作中的应用。

摘要由CSDN通过智能技术生成

一.一维数组

（一）一维数组的定义和初始化

1.数组的概念：一组相同元素的集合

2.一维数组的定义：

数组元素数据类型 数组名[常量表达式]；
//C99前只能使用常量表达式，C99支持变长数组，支持变量但不能初始化；
例：
(1)只定义 
int arr[10];
//定义了数组名为arr的一个整型数组，里面可以存储10个整型；
char arr[10];
//定义了数组名为arr的一个字符数组，里面可以存储10个字符；
float arr[10];
double arr[10];
//定义了数组名为arr的一个浮点数组，里面可以存储10个浮点数；
(2)变长数组
int n=10；
arr[n]; //不能定义的时候直接初始化；
C99之前不能使用变量，C99可以使用；VS不支持C99中的变长数组；gcc可以

3.一维数组的初始化

（1）不写常量表达式时，数组元素个数由初始化内容决定
int arr[]={1,2,3};     //此时数组元素为3
char arr[]={'a','b','c'}; //3
char arr[]={'a',88,'c'}; //88这里指的是ASCII码表上的十进制数，对应的字符是'X'
注:字符数组最简单的初始化
char arr[20]={0};  //0对应的字符是\0
char arr[]="abc";       //用字符串初始化数组，末尾自动加上\0;实际上是4个元素；
（2）写常量表达式
int arr[3]={1,2,3};  
int arr[3]={1};  //不完全初始化，后续2个默认初始化为0

扩展：关于字符数组在内存中的分配问题

字符数组可以通过字符串和大括号进行初始化；

char arr[3]={'a','b','c'}; 
//3个元素，内存中存储 a b c,printf输出可能会出现随机值；

char arr[]="abc";    
//4个元素，内存中存储 a b c '\0'

（二）一维数组的使用

[]是数组下标引用符，用于数组访问，访问元素可用变量
1. 数组是使用下标来访问的，下标是从0开始。
int arr[3]={1,2,3};
arr[0]=1;
arr[1]=2;
arr[2]=3;
数组的下标最大值=数组元素个数(数组的大小)-1
//2=3-1
2. 数组的大小可以通过计算得到。
int arr[3]={0};
int len=sizeof(arr)/sizeof(arr[0]); //3
3.数组元素的输入和输出
#include<stdio.h>
int main()
{
    int arr[3] = { 0 };
    int len = sizeof(arr) / sizeof(arr[0]);
    printf("arr的长度=%d\n",len);
    int i = 0;   //i表示数组元素的下标
    for (i = 0; i < len; i++)
    {
        int n = 0;
        scanf("%d", &n);  //每循环一次，输入一个
        arr[i] = n;
    }
    for (i = 0; i < 3; i++)  //数组元素的打印
    {
        printf("%d ", arr[i]);
    }
    return 0;
}





数组输入：
（1）输一个 空格 输一个 空格，输完，换行
（2）输一个换行，一直输，一直换，直到结束

（三）一维数组在内存中的存储

数组在内存中是连续存放的；

int arr[3]={1,2,3};
定义了一个数组名为a的整型数组，可以存储3个整型元素，一个整型占4个字节，一共占12个字节；
即：每个元素占4个字节，每个字节都有自己的地址；
arr[0]-arr[2] 3个元素的所占的空间相连，由低到高；
&arr[0]=第一个字节所对应的地址，4个地址都指向arr[0];
//2.输出数组元素的地址
#include<stdio.h>
int main()
{
	int arr[3] = { 1,2,3 };
	int len = sizeof(arr) / sizeof(arr[0]);
	//int* p = &arr[0];
	for (int i = 0; i < len; i++) 
	{
		printf("&arr[%d]=%p\n", i, &arr[i]); //&arr[i]表示数组中对应的元素的占得字节的首个字节的地址；
		//printf("%d ", *(p + i)); //用指针的方法打印，整型加1，加4个字节
	}
	return 0;
}

注：

（1）4个字节存储了arr[0]的值，从左往右

（2）字节地址：&arr[0]=012FFECC

32位（二进制）机器

（1）用32个二进制序列表示地址，转换成16进制就是8位16进制机器；（1个16进制=4个二进制数（1个16进制数最大为15，转换成二进制需要4位表示）

（2）一个字节占8个二进制位，就是2个16进制位；

总结：

在32位操作系统（编译器可以设置）：

（1）8个16进制数表示字节地址，如：0x0073FD70

（2）2个16进制数表示一个字节的值；

在64位操作系统：

（1）16个16进制数表示字节地址，如：0x0000007439BCF904

（2）2个16进制数表示一个字节的值；

//3.字节、地址、内存测试
int main()
{
    int a = 1;  //0x0073FD70 01 00 00 00
    int b = 15; //0x0073FD64  0f 00 00 00
    int c = 16; //0x0073FD58  10 00 00 00
    int d= 255;        //0x0073FD4C  ff 00 00 00
    int e = 256;       //0x0073FD34  00 01 00 00
    int f = 65535;      //0x0073FD34  ff ff 00 00
    int g = 65537;      //0x0073FD28  01 00 01 00
    int h = 4294967295;  //0x0073FD1C  ff ff ff ff
    return 0;
}

读取顺序：

从后往前累加

0f 00 00 00 =f
00 01 00 00=100
01 00 01 00=01 00 01
4级 3级 2级 1级

二.二维数组

（一）二维数组的创建

int arr[i][j]; //i=行，j=列
int arr[2][2];  //定义了一个2行2列的二维整型数组,一共4个元素
元素
arr[0][0] arr[0][1] arr[1][0] arr[1][1]
char arr[2][2];
double arr[2][2];

（二）二维数组的初始化

int arr[2][2]={{1,2},{1,2}};  //完全初始化，行和列都用{}表示；
int arr[][2]={{1,2},{1,2}};   //有初始化元素的情况下，可以省略行，但不能省略列
int arr[5][6]={1,2,3};        //部分初始化，未初始化的元素默认为0

（三）二维数组的输入输出

二维数组通过下标来访问元素；

//4.二维数组的输入输出；
#include<stdio.h>
int main()
{
	int arr[3][3] = { 0 };
	int i = 0; //i表示行的下标
	for (i = 0; i < 3; i++)
	{
		int j = 0;  //表示列的下标
		for (j = 0; j <3; j++)
		{
			arr[i][j] = i * 4 + j;  //对每列元素赋值
		}
	}
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 3; j++)
		{
			printf("arr[%d][%d]=%d\n",i,j,arr[i][j]); //按顺序打印输出
		}
	}
	return 0;
}

（四）二维数组在内存中的存储

//5.打印输出二维数组的元素地址；
#include<stdio.h>
int main()
{
	int arr[3][3] = { 0 };
	int i = 0; //i表示行的下标
	for (i = 0; i < 3; i++)
	{
		int j = 0;  //表示列的下标
		for (j = 0; j < 3; j++)
		{
			printf("&arr[%d][%d]=%p\n", i, j ,& arr[i][j]);  //对每列元素赋值
		}
	}
//	int*p = &arr[0][0];
//	int k = 0;
//	for (k = 0; k < 12; k++)
//	{
//		printf("%d ", *(p + k)); //转化成一维数组打印输出
//	}
//
//备注：计算每行每列大小
//	int i = 0;
//	for (i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
//	{
//		int j = 0;
//		for (j = 0; j < sizeof(arr[0])/sizeof(arr[0][0]); j++)
//		{
//			printf("%d ", arr[i][j]);
//		}
//	}
//	printf("\n");

	return 0;
}

总结：随着下标的增长，对应的元素的地址递增，二维数组中的元素在内存中也是连续存储的

三.数组越界

数组的下标是有范围限制的，需要小于元素个数-1；

//6.数组越界显示
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
	}
	return 0;
}

二维数组行和列也存在越界可能；

越界访问标志；

四.数组作为函数参数

（一）数组名的意义

1.数组名=数组首元素地址；

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3 };
	printf("%p\n", arr);     //数组名=数组首元素地址
	printf("%p\n", &arr[0]);  //数组首元素地址
	printf("%d\n", *arr);     //数组名指向的变量（元素）的值；
	printf("%p\n", &arr);      
	printf("%d\n", sizeof(arr));
	return 0;
}

注：除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

1. sizeof(数组名)，计算整个数组的大小，及所有元素所占字节数的总和，sizeof内部单独放一个数组名，数组名表示整个数

组。

2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

（二）对数组进行冒泡排序

数组名作为参数，传递的是数组首地址；

形式参数 int arr[]等价于int *arr;

进入函数后内部后，看数组全元素，数组名，元素个数

//#include <stdio.h>
//void bubble_sort(int arr[]) //函数内部求参数部分数组的大小，不可取
//{
//	int sz = sizeof(arr) / sizeof(arr[0]);//这样对吗？调试算出，sz=1;这里本质上arr是个指针，sizeof(arr)计算的是指针的大小，而不是数组的大小，1/1=1
//	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;
//			}
//		}
//	}
//}
void Sort(int *arr, int sz) //这里写数组，指针都可以
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序,决定了一趟排序进行多少对比较
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) //第一趟 9对，正向排序
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

void Sort(int arr[], int sz)
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)  //决定趟数
	{
		//一趟冒泡排序,决定了一趟排序进行多少对比较
		int j = 0;
		for (j = 0; j < sz-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	//整型数据
	int arr[] = { 3,1,4,2,9,8,6,7,0,5 };
	//写一个函数对数组进行排序
	int sz = sizeof(arr) / sizeof(arr[0]);

	Sort(arr, sz);  //sizeof里的数组名和这里的数组名意义不一致
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}



//arr[i] --> *(arr+i)  等价
//&arr[i] -- arr+i
//