C语言-函数-9

函数

1. 库函数   

1）调用 strcpy() 函数将 arr2 数组中的内容复制到 arr1 数组中。strcpy() 函数的参数依次为目标数组的地址和源数组的地址。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = { "hello kety!"};
	strcpy(arr1, arr2);      
    //调用 strcpy() 函数将 arr2 数组中的内容复制到 arr1 数组中。strcpy() 函数的参数依次为目标数组的地址和源数组的地址。
	printf("%s", arr1);

	return 0;
}

 2）调用 memset() 函数将 arr 数组中的前5个字符替换为字符 '*'。memset() 函数的参数依次为替换的目标地址、替换的字符、替换的长度。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = { "hello kety!" };
	memset(arr, '*', 5);  
	printf("%s", arr);
	return 0;
}

2、自定义函数

1）用函数取较小值

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int get_min(int m, int n)
{
	int p;
	if (m > n)
	{
		p = n;
	}
	else
	{
		p = m;
	}
	return p;
}
int main()
{
	int a = 0;
	int b = 0;
	printf("请输入两个整数：\n");
	scanf("%d %d", &a, &b);
	int min = get_min(a, b);
	printf("%d\n", min);
	return 0;
}

2）a和b的值互换

使用指针和不使用指针有以下区别：

1. 传递参数的效果：使用指针作为函数参数可以通过引用传递来改变实际变量的值，而不仅仅是在函数内部产生副本的修改。这意味着使用指针可以在函数外部影响到实际的变量。而不使用指针，则只会在函数内部进行副本的修改，不会对外部的变量产生影响。
2. 内存开销：使用指针传递参数时，只需传递变量的地址，而不是整个变量的值，这可以节省内存开销和传递参数的时间。相比之下，不使用指针时，需要在函数调用时复制变量的值作为参数，会产生额外的内存开销和时间消耗。
3. 引用传递：使用指针可以实现引用传递的效果，即通过修改指针所指向的内存单元来修改实际变量的值。而不使用指针，则无法进行引用传递，只能通过副本的方式传递参数，无法直接影响实际变量。
4. 灵活性：使用指针可以在函数内部灵活地操作和访问内存中的数据。指针可以用于数组、链表、动态内存分配等数据结构的操作。而不使用指针则无法直接访问内存地址，限制了对复杂数据结构的操作和灵活性。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void swap(int* pa,int* pb)
{
	int p = 0;
	p =*pa;
	*pa =*pb;
	*pb= p;
}
int main()
{
	int a = 10;
	int b = 20;
	printf("a=%d,b=%d\n", a, b);
	swap(&a,&b);
	printf("a=%d,b=%d\n", a, b);
	return 0;
}

3）用函数打印100-200之间的质数

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int is_prime(int n)
{
	int m = 0;
	for (m = 2;m < n;m++)
	{
		if (n % m == 0)
			return 0;
	}
	return 1;
}
int main()
{
	int i = 100;
	int count = 0;
	for (i = 100;i <= 200;i++)
	{
		if (is_prime(i) == 1)
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\ncount=%d", count);
	return 0;
}

4）用函数判断一个数是否闰年

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int is_year(int* pa)
{
	int a = *pa;
	if ((a % 4 == 0 && a % 100 != 0) || (a % 400 == 0))
	{
		return 1;
	}
	else
	{ 	
		return 0;
	}
}
int main()
{
	int i = 0;
	printf("请输入一个数： ");
	scanf("%d",&i);
	if (is_year(&i))
	{
		printf("闰年");
	}
    else
    {
        printf("平年");
    }
	return 0;
}

 

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int isLeapYear(int year)
{
    if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) 
	{
        return 1; // 是闰年
    }
	else
	return 0; // 不是闰年
}
int main()
{
    int year;
    printf("请输入一个年份：");
    scanf("%d", &year);
    if (isLeapYear(year)) 
	{
        printf("%d年是闰年\n", year);
    }
    else 
	{
        printf("%d年不是闰年\n", year);
    }
    return 0;
}

5）用函数实现一个整形有序的二分查找

写 if (-1 == ret) 是一种常见的习惯用法，被称为"Yoda 条件语句"，在条件判断中将比较运算符 == 的左侧写成常量或字面量，而将变量或表达式写在右侧。

这种习惯用法的目的是为了避免在条件判断中使用赋值运算符 = 而产生的错误。如果不小心将条件判断的语句写成 if (ret = -1)，即将 == 写成了 =，会导致将 -1 赋值给 ret，并且条件表达式的值始终为 -1（非零值），结果会产生编译错误或逻辑错误。

 #define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int binary_search(int a[],int b,int s)
{
	int left = 0;
	int right = s - 1;
	while (left<=right)
	{ 
		int mid = (left + right) / 2;
	if (a[mid] > b)
	{
		right = mid - 1;
	}
	else if(a[mid]<b)
	{
		left = mid + 1;
	}
	else
	{
		return mid;
	}
	}
	return -1;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int m = 3;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int ret = binary_search(arr, m, sz);
	if (-1 == ret)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是：%d\n", ret);
	}
}