BSP学习Day12 C语言基础宏函数和函数调用的区别变量类型及存储地址讲解将数组传递给函数冒泡排序

慕容离875

已于 2022-08-23 20:02:24 修改

阅读量424

点赞数

文章标签：学习

于 2022-08-23 20:01:36 首次发布

本文链接：https://blog.csdn.net/qq_59947178/article/details/126488380

版权

以上是近两年学习的相关数组的思维导图

1.宏函数和函数调用的区别

1、在源程序进行编译之前，也就是在预编译时进行宏替换，而函数调用则发生在程序运行期间;

2、在预处理阶段，对宏函数的参数不做检查,即宏定义时不需要指定参数类型,适用于多种数据类型，即是优点也是缺点。

函数参数类型检查严格，程序在编译阶段,需要检查实参和形参个数是否相等及类型匹配，若参数个数不相同或类型不兼容,则会编译不通过;

3、宏定义只是简单的文本替换，即替换完就把宏名对应的标识符删除掉，即不分配空间，而函数调用时，需要为形参分配空间，并把实参的值复制一份赋给形参分配的空间中。|

4、函数在编译阶段需要检查参数个数是否相同，类型是否匹配等多个语法，而宏替换仅是简单的文本替换，不做任何语法或逻辑检查函数在运行阶段参数需要入栈和出栈操作，速度相对较慢

5、宏替换是文本替换，即如果需要替换的文本较长,则替换后会影响代码长度，而函数不会影响代码长度。

2.变量类型及存储地址讲解

#include <stdio.h>

int main()
{
	/* long long型 数组空间存储测试*/
	long long arr_ll[5]={10,11,12,13,14};
	printf("long long类型空间大小：%d\n",sizeof(long long));
	printf("arr_ll[0]变量的地址：%#p\n",&arr_ll[0]);
	printf("arr_ll[1]变量的地址：%#p\n",&arr_ll[1]);
	printf("arr_ll[2]变量的地址：%#p\n",&arr_ll[2]);
	printf("arr_ll[3]变量的地址：%#p\n",&arr_ll[3]);
	printf("arr_ll[4]变量的地址：%#p\n",&arr_ll[4]);
	
	printf("arr_ll[5]变量的地址：%#p\n",&arr_ll[5]);
	printf("arr_ll[5]变量的内容：%d\n",arr_ll[5]);


	/* int型 数组空间存储测试*/	
	int arr_int[5]={10,11,12,13,14};
	printf("int类型空间大小：%d\n",sizeof(int));
	printf("arr_int[0]变量的地址：%#p\n",&arr_int[0]);
	printf("arr_int[1]变量的地址：%#p\n",&arr_int[1]);
	printf("arr_int[2]变量的地址：%#p\n",&arr_int[2]);
	printf("arr_int[3]变量的地址：%#p\n",&arr_int[3]);
	printf("arr_int[4]变量的地址：%#p\n",&arr_int[4]);

	/* char型 数组空间存储测试*/	
	char arr_ch[5]={10,11,12,13,14};
	printf("char类型空间大小：%d\n",sizeof(char));
	printf("arr_ch[0]变量的地址：%#p\n",&arr_ch[0]);
	printf("arr_ch[1]变量的地址：%#p\n",&arr_ch[1]);
	printf("arr_ch[2]变量的地址：%#p\n",&arr_ch[2]);
	printf("arr_ch[3]变量的地址：%#p\n",&arr_ch[3]);
	printf("arr_ch[4]变量的地址：%#p\n",&arr_ch[4]);


	/* int型 变量空间存储测试*/				
	int num=100;
	printf("int类型空间大小：%d\n",sizeof(int));
	printf("num变量的地址：%#p\n",&num);
	printf("num变量的地址：%p\n",&num);
	printf("num变量的内容：%d",num);
	

	
	/* char型 变量空间存储测试*/	
	char ch='a';
	printf("char类型空间大小：%d\n",sizeof(char));
	printf("ch变量的地址：%#p\n",&ch);
	printf("ch变量的内容：%x",ch);
	
	
	return 0;
 }

3.数组越界

指数组下标变星的取值超过了初始定义时的大小，导致对数组元素的访问出现在数组的范围之外

1.概念:数组是有固定长度的,如果获取超出数组的长度,就称数组越界;

2.越界结果:会拿到不确定的值或程序报错

3.由上一节得知，越界为什么会不可靠。

4.数组名用途

1.利用sizeof(数组名)可以统计整个数组占用内存空间大小

printf("%d\n" ,sizeof(arr));

2.可以计算数组元素个数

printf("%d\n" , sizeof(arr)/sizeof(int));

3.可以利用数组名，获取数组首地址

printf("%p"，arr);

printf("%p"，&arr [0]);printf("%p"，&arr[1]);

4.数组名是常量，不可以修改

arr = 100; //报错

5.将数组传递给函数

数组元素作为实参引用的时候，和变量操作-样，只是单向值传递主调一>被调

#include<stdio.h>
//数组作为入参传递给函数 ，在函数定义时要加[] 
int modify_arr(int a[],int length,int num)
{
	a[0] = num;
	return 0;
}

int modify_all(int a[],int length)
{
	int i;
	for(i=0;i<length;i++)
	{
		a[i] += 10;
	}
	return 0;
}

int print_arr(int a[],int length)
{
	int i;
	for(i=0;i<length;i++)
	{
		printf("%d ",a[i]);
	}
	printf("\n");
	return 0;
}

int main() 
{
	数组作为入参传递给函数 ，在函数调用时直接写数组名 
	int arr[6] = {1,2,3,4,5,6}; //定义个整型的数组，长度是6 
	print_arr(arr,6);  //将数组中的元素打印出来 
	modify_arr(arr,6,11);//修改数组中的某个元素 
	print_arr(arr,6); 
	modify_all(arr,6);//修改数组中的每个元素 
	print_arr(arr,6);
	return 0;
}

将一个数组作为实参传递给一个函数，主调函数只需要传递数组名和数组大小。将一个数组作为形参时，形参定义数组名]和int数组大小

6.冒泡排序

一种较为简单的排序算法

/*冒泡排序
9   2   1   4   7   3
2   1   4   7   3   9          //交换了5次     N-1次第一趟比较后
1   2   4   3   7   9          //交换了2次 N-2次第二趟比较后
1   2   3   4   7   9          //交换了1次第三趟比较后
1   2   3                   //交换了0次第四趟比较后
1   2                            //交换了0次第五趟比较后
*/

下例是5个数的排列

#include<stdio.h>
#define N 6

int pop_arr(int a[],int length)
{
	int i,j;
	int temp = 0;
	for(i=0;i<length-1;i++)
	{
		for(j=0;j<length-1-i;j++)
		{
			if(a[j]>a[j+1])
			{
				temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
			}
		}
	}
	return 0;
}

int print_arr(int a[], int length)
{
	int i;
	for(i=0;i<N;i++)
	{
		printf("%d ",a[i]);
	}
	return 0;
}

int main()
{
	int arr[N] = {9,2,1,4,7,3};
	pop_arr(arr,N);
	print_arr(arr,N);
	return 0;
}