练习题——数组传参

最新推荐文章于 2022-11-08 09:23:08 发布

苜—

最新推荐文章于 2022-11-08 09:23:08 发布

阅读量143

点赞数

文章标签： c语言

本文链接：https://blog.csdn.net/m0_68071216/article/details/124294392

版权

这篇博客介绍了如何使用C语言实现100-200之间的素数打印，1000-2000之间的闰年判断，以及一个有序整数数组的二分查找函数。还探讨了C99中bool类型的使用，并展示了如何编写每次调用都会使变量num加1的函数。此外，文章讨论了数组作为函数参数时的内存传递问题，强调了在函数内部计算数组长度的不准确性。

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

3. 写一个函数，实现一个整形有序数组的二分查找。

C99中引进了bool类型：

4. 写一个函数，每调用一次这个函数，就会将 num 的值增加1。

函数的功能尽量足够单一

1. 打印100-200之间的素数。

用for循环实现

//打印100-200之间的素数
//素数是只能被1和它本身整除的数
#include<stdio.h>
int main()
{
	int i = 0;
	int count = 0;
	for (i = 100; i <= 200; i++)
	{
		//判断i是否为素数
		//是素数就打印
		//拿2 - i-1之间的数去试验i
		int flag = 1;//falg是1表示是素数，是0表示不是素数
		int j = 0;
		for (j = 2; j <= i - 1; j++)
		{
			if (i % j == 0)
			{
				flag = 0;
				break;
			}
		}
		if (flag == 1)
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\n%d\n", count);
	return 0;
}

输出结果是：

优化方法

//m=a*b
//16=2*8
// =4*4
//a和b中一定有一个数字是<=sqrt(m)——开平方

//sqrt是数学库函数，它的头文件是 math.h

用int也是可以的。

故代码可写成：(注意：调用sqrt()要引用头文件 #include<math.h> )

#include<stdio.h>
#include<math.h>

int main()
{
	int i = 0;
	int count = 0;
	for (i = 100; i <= 200; i++)
    //因为偶数不可能是素数，所以还可以写成
    //for (i = 101; i <= 200; i+=2)
	{
		//判断i是否为素数
		//是素数就打印
		//拿2 - i-1之间的数去试验i
		int flag = 1;//falg是1表示是素数，是0表示不是素数
		int j = 0;
		for (j = 2; j <= sqrt(i); j++)
		{
			if (i % j == 0)
			{
				flag = 0;
				break;
			}
		}
		if (flag == 1)
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\n%d\n", count);
	return 0;
}

写一个函数来实现

#include<stdio.h>
#include<math.h>
//是素数返回1，不是素数返回0
int is_prime(int n)
{
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return 0;
		}
	}
    return 1;
	//不需要break，因为return的功能比break更强大
}
int main()
{
	int i = 0;
	int count = 0;
	for (i = 100; i <= 200; i++)
	{
		//判断i是否为素数
		//是素数就打印
		//拿2 - i-1之间的数去试验i
		if (is_prime(i))//返回值为1则真，返回值为0则假
		{
			printf("%d ", i);
			count++;
		}

	}
	printf("\ncount=%d\n", count);
	return 0;
}

2. 打印1000-2000之间的闰年

用for循环实现

//打印1000-2000之间的闰年
//闰年的判断规则：能被4整除且不能被100整除，或能被400整除
#include<stdio.h>
int main()
{
	int year = 0;
	for (year = 1000; year <= 2000; year++)
	{
		//判断每个人循环产生的year是不是闰年
		if (year % 4 == 0)
		{
			if (year % 100 != 0)
			{
				printf("%d ", year);
			}
		}
	    if (year % 400 == 0)
		{
			printf("%d ", year);
		}
	}
	return 0;
}

简化一下：

//打印1000-2000之间的闰年
//闰年的判断规则：能被4整除且不能被100整除，或能被400整除
#include<stdio.h>
int main()
{
	int year = 0;
	for (year = 1000; year <= 2000; year++)
	{
		//判断每个人循环产生的year是不是闰年
		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
		{
			printf("%d ", year);

		}
	}
	return 0;
}

输出结果是：

写一个函数来实现

#include<stdio.h>
//是闰年返回1，不是闰年返回0
int is_leap_year(int y)
{
	if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
		return 1;
	else
		return 0;
}
int main()
{
	int year = 0;
	for (year = 1000; year <= 2000; year++)
	{
		//判断每个人循环产生的year是不是闰年
		if (is_leap_year(year))
		{
			printf("%d ", year);

		}
	}
	return 0;
}

3. 写一个函数，实现一个整形有序数组的二分查找。

//3. 写一个函数，实现一个整形有序数组的二分查找。
#include<stdio.h>
int binary_search(int arr[], int k, int sz)
{
    、、形式参数和实际参数的名字可以相同，也可以不同
	int left = 0;
	int right = sz - 1;
	while (left<=right)
	{
		
		int mid = left + (right - left) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			return mid;//找到了，返回下标mid
		}
	}
	return -1;//找不到
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 7;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//找到了返回下标，找不到，返回-1(下标不可能是-1)
	int ret = binary_search(arr, k, sz);//函数传参时只能传arr，不能传arr[],写数组名就可以了
	   //去哪里查(arr)，查什么(k)
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是：%d\n", ret);
	}
	return 0;
}

输出结果是：

问：为什么不把 int sz = sizeof(arr) / sizeof(arr[0])；放到 binary_search( ) 函数内？

//当我们把int sz = sizeof(arr) / sizeof(arr[0]);放到binary_search()函数内时
//错误代码演示
#include<stdio.h>
int binary_search(int arr[], int k)
{
	int sz = sizeof(arr) / sizeof(arr[0]);
    //数组传参实际上传的是数组首元素的地址，而不是整个数组
    //所以在函数内部计算一个函数参数部分的数组的元素个数是不靠谱的
	int left = 0;
	int right = sz - 1;
	while (left <= right)
	{

		int mid = left + (right - left) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			return mid;//找到了，返回下标mid
		}
	}
	return -1;//找不到
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 7;
	//找到了返回下标，找不到，返回-1(下标不可能是-1)
	int ret = binary_search(arr, k);
	//去哪里查(arr)，查什么(k)
	if (ret == -1)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是：%d\n", ret);
	}
	return 0;
}

输出的结果是：

解释：

因为left和right都为0；所以我们只能锁定第一个元素 1 ，故当我们想查找 7 和 17 时，会打印出“找不到”。

为什么sz的值是1？

如图所示，当向函数传参时，我们是将n的值传给了m，那么数组的传参也是这样吗？

结论:当数组传参时，不可能将主函数数组内的所有元素都传向所调用的函数，因为这样的话，函数得创建很大的空间，会造成空间的浪费。所有数组的传参只会将数组的首元素的地址传给调用的函数，虽然int arr[]看起来像指针，实际上却是一个指针变量，用来存放主函数中arr传过来的首地址。既然函数中的arr不是数组，而是一个指针变量，所以sizeof(arr)=4/8，sz=1，所以会导致right的值变成0，只能锁定第一个元素。出现上面的结果。（while循环内left，right，mid所有的下标其实都是在访问主函数的数组arr[ ]中的元素——通过传过来的首地址，进而可以访问主函数中数组arr[ ]的所有元素）

数组传参实际上传的是数组首元素的地址，而不是整个数组
所以在函数内部计算一个函数参数部分的数组的元素个数是不靠谱的

C99中引进了bool类型：

bool flag=true；

bool flag=false；只有两种值

//判断一个数是不是素数
bool is_prime(int n) 
{
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return false;
		}
	}
	return true;
}

4. 写一个函数，每调用一次这个函数，就会将 num 的值增加1。

//4. 写一个函数，每调用一次这个函数，就会将 num 的值增加1。
#include<stdio.h>
void Add(int* p)
{
	(*p)++;//已经要num加1了，所以返回类型可以写成void
}
int main()
{
	int num = 0;
	Add(&num);
	printf("%d\n", num);
	Add(&num);
	printf("%d\n", num);
	Add(&num);
	printf("%d\n", num); 
	Add(&num);
	printf("%d\n", num); 
	Add(&num);
	printf("%d\n", num); 
	Add(&num);
	printf("%d\n", num);
	Add(&num);
	printf("%d\n", num);
	return 0;
}

输出结果是：

另一个fang'f

#include<stdio.h>
int Add(int n)
{
	//return ++n;
	return n+1;//已经要num加1了，所以返回类型可以写成void
}
int main()
{
	int num = 0;
	num=Add(num);
	printf("%d\n", num);
	num=Add(num);
	printf("%d\n", num);
	num=Add(num);
	printf("%d\n", num);
	num=Add(num);
	printf("%d\n", num);
	num=Add(num);
	printf("%d\n", num);
	num=Add(num);
	printf("%d\n", num);
	num=Add(num);
	printf("%d\n", num);
	return 0;
}