函数的认识

---

文章目录

• 函数是什么
• 库函数 
• 自定义函数 
• 函数参数 
• 函数调用 
• 函数的嵌套调用和链式访问 
• 函数的声明和定义
• 函数递归

---

一、函数是什么

维基百科中对函数的定义：子程序

        在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method,

subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组

成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。

        般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软

件库。

二、库函数

为什么会有库函数？

1. 我们知道在我们学习 C 语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想 把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格 式打印到屏幕上（ printf ）。

2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（ strcpy ）。

3. 在编程是我们也计算，总是会计算 n 的 k 次方这样的运算（ pow ）。 像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到， 为了支持可移植性和提高程序的效率，所以 C 语言的基础库中提供了一系列类似的库函数，方便程序员 进行软件开发。

查阅库函数C/C++

C语言常用的库函数都有：

IO 函数

字符串操作函数

字符操作函数

内存操作函数

时间 / 日期函数

数学函数

其他库函数

memset

void * memset ( void * ptr , int value , size_t num );

#include
#include

int main()
{
	//利用英文文档学习memset
	// 
	//设置内存的时候是以字节为单位的
	//每个字节的内容都是一样的value

	char arr[] = "hello world";
	memset(arr , 'x', 5);
	printf("%s", arr);
	return 0;
}

注意：

        库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。

三、自定义函数

        自定义函数和库函数一样，有函数名，返回值类型和函数参数。

但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。

函数的组成：

ret_type fun_name ( para1 , * )

{

        statement ; // 语句项

}

ret_type 返回类型

fun_name 函数名

para1     函数参数

 自定义函数练习：

#include

//写一个函数可以找出两个数的最大值

int get_max(int x, int y)
{
	if (x > y)
		return x;
	else
		return 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\n", m);
	return 0;
}

#include

//写一个函数可以交换两个整形变量的内容
void swap(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);
	swap(&a, &b);
	printf("交换后：a=%d,b=%d\n", a, b);
	return 0;
}

四、函数参数

实际参数（实参）：

真实传给函数的参数，叫实参。

实参可以是：常量、变量、表达式、函数等。

无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形

参。

形式参数（形参）：

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内

存单 元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有 效。

五、函数调用

传值调用

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

传址调用

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

函数练习：

#include
#include

//写一个函数求素数
int is_prime(int 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 (int i = 100; i <= 200; i++)
		if (is_prime(i) == 1)
			printf("%d ", i);

	return 0;
}

#include

//写一个函数判断一年是不是闰年
int is_leap_year(int y)
{
	return (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0));
}

int main()
{
	//1000~2000年的闰年
	int y = 0;
	for (y = 1000; y <= 2000; y++)
		if (is_leap_year(y) == 1)
			printf("%d ", y);
	return 0;
	return 0;
}

#include

//二分查找
int binary_search(int arr[], int k, int sz)
{
	int left = 0;
	int right = sz - 1;

	while (left <= right) {
		int mid = left + (right - left) >> 1;
		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,10 };
	int k = 0;
	scanf("%d", &k);//要查找的元素
	int sz = sizeof(arr) / sizeof(arr[0]);
	int ret = binary_search(arr, k, sz);
	if (ret == -1)
		printf("找不到\n");
	else
		printf("找到了，下标是:%d\n", ret);
	return 0;
}

#include

//写一个函数，每调用一次这个函数，就会将 num 的值增加1。
void test(int* p)
{
	*p = *p + 1;
}

int main()
{
	int num = 0;
	test(&num);
	printf("%d\n", num);
	return 0;
}

六、函数的嵌套调用和链式访问

嵌套调用

#include 

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;
}

链式访问

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

#include 
#include 

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

#include 
int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	//结果是啥？
	//注：printf函数的返回值是打印在屏幕上字符的个数
	return 0;
}

注意：        

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

七、函数的声明和定义

函数声明：

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数

声明决定不了。

2. 函数的声明一般出现在函数的使用之前。要满足 先声明后使用 。

3. 函数的声明一般要放在头文件中的。

test.h 的内容

放置函数的声明

#ifndef __TEST_H__

#define __TEST_H__

// 函数的声明

int Add ( int x , int y );

#endif //__TEST_H__

test.c 的内容

放置函数的实现

#include "test.h"

// 函数 Add 的实现

int Add ( int x , int y )

{

return x + y ;

}

如果不愿意暴露代码，可以将所写的函数使用静态库的方式：

八、函数递归

什么是递归？

程序调用自身的编程技巧称为递归（ recursion ）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接 调用自身的 一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，

递归策略 ：只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于：把大事化小

递归的两个必要条件：

        存在限制条件，当满足这个限制条件的时候，递归便不再继续。

        每次递归调用之后越来越接近这个限制条件。

练习：

#include 

//接受一个整型值（无符号），按照顺序打印它的每一位。
void print(int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}

int main()
{
	int num = 1234;
	print(num);
	return 0;
}

#include

//编写函数不允许创建临时变量，求字符串的长度。
int Strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + Strlen(str + 1);
}

int main()
{
	const char* p = "abcd";
	int len = Strlen(p);
	printf("%d\n", len);
	return 0;
}

#include

//求n的阶乘
int factorial(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * factorial(n - 1);
}

int main()
{
	int n = 0;
	scanf("%d", &n);

	int ret = factorial(n);
	printf("%d\n", ret);
	return 0;
}

#include

//求第n个斐波那契数。
int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

int main()
{
	int n = 0;
	scanf("%d", &n);

	int ret = fib(n);
	printf("%d\n", ret);
	return 0;
}