C语言中的函数

1. 函数是什么？

• 在计算机科学中，子程序是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
• 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

2. C语言中函数的分类

2.1 库函数

简单的总结，C语言常用的库函数都有：

• IO函数（输入输出函数）
• 字符串操作函数
• 字符操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

例如：C语言标准，就可以规定库函数的标准：

           int strlen(const char* str);

           功能：求str指向的字符串的长度

#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = "abcedf";
	char arr2[] = { 0 };
	//能把arr中的abcdef拷贝到arr2中
	strcpy(arr2, arr1);

	printf("%s\n", arr2);
	return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "hello China";
	memset(arr, 'X', 5);//改变arr+，可以改变修改的位置
	//1.设置内存的时候是以字节为单位的
	//2.每个字节的内容都是一样的value
	printf("%s\n", arr);//XXXXX China
	return 0;
}

2.2 自定义函数

函数的组成：

ret_type fun_name(para1, * )
{
 statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1    函数参数

//写一个函数可以找出两个整数中的最大值
#include <stdio.h>
int get_max(int x, int y)
{
	/*if (x > y)
		return x;
	else
		return y;*/
	return x > y ? x : y;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d%d", &a, &b);
	//使用函数求a和b的较大值
	//Max();
	int m=get_max(a,b);
	printf("%d", m);

	return 0;
}

//写一个函数可以交换两个整形变量的内容
#include <stdio.h>
//形参
void swap(int x, int y)
{
	int tmp = 0;
	tmp =x;
	x = y;
	y = tmp;

}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);

	printf("交换前：a=%d,b=%d\n", a, b);
	//实参
	swap(a, b);
	printf("交换后：a=%d,b=%d\n", a, b);

	return 0;
}
//结果是并没有改变a,b的值

结果错误的原因：当实参传给形参的时候，形参是实参的一份临时拷贝，对形参的修改不会影响实参

//利用指针改变a的值
#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;

	*pa = 20;
	printf("%d\n", a);

	return 0;

}

#include <stdio.h>
//形参
//void swap1(int x, int y)
//{
//	int tmp = 0;
//	tmp =x;
//	x = y;
//	y = tmp;
//
//}
void swap2(int* pa, int* pb)
{
	int tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);

	printf("交换前：a=%d,b=%d\n", a, b);
	//实参
	//swap1(a, b);
	swap2(&a, &b);
	printf("交换后：a=%d,b=%d\n", a, b);

	return 0;
}

3. 函数的参数

3.1 实际参数（实参）

• 真实传给函数的参数，叫实参。
• 实参可以是：常量、变量、表达式、函数等。
• 无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

3.2 形式参数（形参）

    形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

4. 函数的调用

4.1 传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

4.2 传址调用

• 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
• 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操 作函数外部的变量。

4.3 程序例子

1. 写一个函数可以判断一个数是不是素数

// 写一个函数可以判断一个数是不是素数
//is_prime(i)
//返回1是素数
//返回0表示不是素数

#include <stdio.h>
#include <math.h>
int is_prime(int n)
{
	//用2~n-1试除
	//用2~sqrt(n)试除
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return 0;
		}
	}
	return 1;
}
int main()
{
	//打印100~200之间的素数
	int i = 0;
	for (i = 100; i <= 200; i++)
	{
		//判断i是否为素数
		if (is_prime(i) == 1)
		{
			printf("%d ", i);
		}
	}
	return 0;
}

2.写一个函数判断一年是不是闰年

//写一个函数判断一年是不是闰年
#include <stdio.h>
int is_leap_year(int y)
{
	/*if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
		return 1;
	else
		return 0;*/
	return ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0);
}
int main()
{
	//1000~2000年的闰年
	int y = 0;
	for (y = 1000; y <= 2000; y++)
	{
		//判断y是不是闰年
		if (is_leap_year(y) == 1)
		{
			printf("%d ", y);
		}
	}
	return 0;
}

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

// 写一个函数，实现一个整形有序数组的二分查找
//找到了就返回下标
//找不到就返回-1
#include <stdio.h>
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;
		}
	}
	return -1;//找不到
}
int main()
{
	//数组在传参的时候，传递的不是整个数组
	//而是传递的首元素的地址
	int arr[] = { 1,2,3,4,5,6,7,8,9 };
	int k = 0;
	scanf("%d", &k);//要查找的元素
	int sz = sizeof(arr) / sizeof(arr[0]);
	int ret=binary_search(arr, k, sz);
	if (-1 == ret)
		printf("找不到\n");
	else
		printf("找到了，下标是：%d\n",ret);
	return 0;
}

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

//写一个函数，每调用一次这个函数，就会将 num 的值增加1
#include <stdio.h>
void test(int* p)
{
	*p = *p + 1;
	//(*p)++;
}
int main()
{
	int num = 0;
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	return 0;
}

5. 函数的嵌套调用和链式访问

函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。

5.1 嵌套调用

#include <stdio.h>
void new_line()
{
 printf("hehe\n");
}
void three_line()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        new_line();
   }
}
int main()
{
 three_line();
 return 0; }

函数可以嵌套调用，但是不能嵌套定义。

5.2 链式访问

把一个函数的返回值作为另外一个函数的参数。

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
 int ret = strlen(strcat(arr,"bit"));//这里介绍一下strlen函数
 printf("%d\n", ret);
 return 0; }

#include <stdio.h>
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    return 0;
 }
//打印：4321

6. 函数的声明和定义

6.1 函数声明

•  告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数 声明决定不了。
• 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
•  函数的声明一般要放在头文件中的。

6.2 函数定义

函数的定义是指函数的具体实现，交待函数的功能实现

//求两个数相加的和

#include <stdio.h>
//函数的声明
//形参的名字可以省略
//int Add(int x, int y);
int Add(int, int);

int main()
{
	int a = 0;
	int b = 20;
	int sum = Add(a, b);
	printf("%d\n", sum);
	return 0;
}

//函数的定义
int Add(int x, int y)
{
	return x + y;
}

test.h的内容

放置函数的声明

//函数的声明
int Add(int x, int y);

test.c的内容

放置函数的实现

#include "test.h"
//函数Add的实现
int Add(int x, int y)
{
 return x+y; 
}