C语言------函数(初阶)-CSDN博客

子程序(英语:Subroutine,procedure,function,routine,method,subprogram,callable unit),是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定的任务，而且相较于其他代码，具备相对的独立性。
一般会有输入参数并具有返回值，提供对过程的封装和细节的隐藏，这些代码通常背集成为软件库。

2.C语言中函数的分类:

库函数
自定义函数

2.1库函数：

为什么会有库函数？

我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把结果打印在屏幕上，这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印在屏幕上(printf)。
字符串的拷贝工作(strcpy)。
计算n的k次方的运算(pow)。

像上边描述的基础功能，它们不是业务性的代码，我们在开发的过程中每个程序员都会用到，

为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列的库函数

学习库函数：https://cplusplus.com/

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

IO函数
字符串操作函数
字符操作函数
内存操作函数
时间/日期函数
数学函数
其他库函数

例如：

strcpy

char * strcpy(char * destiantion,const char * source);

memset

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

注：使用库函数，必须包含#include对应的头文件。

2.1.1如何学会使用库函数

不需要全部记住，学会使用查询工具：

https://cplusplus.com

en.cppreference.com

zh.cppreference.com (中文版)

2.2自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数，但是需要我们自己设计。

比如设计一个函数可以交换两个整形变量的内容。

#include<stdio.h>
//设计一个函数可以交换两个整形变量的内容
void swap(int* x, int* y)
{
	int temp = 0;
	temp = *x;
	*x = *y;
	*y = temp;
}
int main()
{
	int n = 1;
	int m = 2;
	printf("n=%d m=%d\n", n, m);
	swap(&n, &m);
	printf("n=%d m=%d", n, m);
	return 0;
}

3.函数的参数

3.1实际参数(实参)

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

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

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

3.2形式参数(形参)

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

比如说在上一个代码中，x,y是形参，&n和&m是实参。

注：形参拥有自己的空间，同时拥有了和实参一模一样的内容，所以可以认为形参实例化之后其实相当于实参的一份临时拷贝。

4.函数的调用

4.1传值调用

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

4.2传址调用

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

4.3练习

//判断一个数是否为素数
#include<stdio.h>
#include<math.h>
int prime(int n)
{
	int i=0;
	for (i = 2; i <= sqrt(n); i++) {
		if (n % i == 0) {
			return 0;
		}
	}
	return 1;
}
int main()
{
	int j=0;
	int count=0;
	for (j =100; j <= 200; j++) {
		if (prime(j) == 1)
		{
			printf("%d ", j);
			
			count++;
		}
	}
	printf("\ncount=%d\n", count);
	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<string.h>
int main()
{
	char arr[20] = "heelo";
	int ret = strlen(stract(arr, "bit"));
	printf("%d\n", ret);
	return 0;
}

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

6.函数的声明和定义

6.1函数声明

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

6.2函数定义

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

实现

test.h的内容:放置函数的声明

#ifndef __TEST_H__
#define __TSET_H__
//函数声明
int Add(int x,int y);

#endif  //__TEST_H__

test.c的内容:放置函数的实现

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

7.函数递归

7.1什么是函数递归

程序调用自身的编程技巧称为递归（ recursion）。

递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

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

7.2递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件

练习：接收一个整型值(无符号),按照顺序打印其每一位

7.3递归与迭代

求n的阶乘

#include<stdio.h>
//求n的阶乘
int factorial(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * factorial(n - 1);
}
int main()
{
	int n;
	printf("输入一个数:>");
	scanf("%d", &n);
	int ret = factorial(n);
	printf("%d", ret);
 return 0;
}

求第n个斐波那契数

int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}
int main()
{
	int n;
	printf("请输入一个数字:>");
	scanf("%d", &n);
	int ret = fib(n);
	printf("%d", &fib);
	return 0;
}

但是我们发现有问题；

使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。

使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？

我们发现 fib 函数在调用的过程中很多计算其实在一直重复。

对其进行以下修改：

int count = 0;//全局变量
int fib(int n)
{
    if (n == 3)
        count++;
    if (n <= 2)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}

最后我们输出看看count，是一个很大很大的值。

那我们如何改进呢？

在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）这样的信息。系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。

那如何解决上述的问题：

将递归改写成非递归。
使用 static 对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代 nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

以下是用非递归的写法

//求n的阶乘
int factorial(int n)
{
	int result = 1;
	while (n > 1)
	{
		result *= n;
		n -= 1;
	}
	return result;
}

//求第n个斐波那契数
int fib(int n)
{
	int result;
	int pre_result;
	int next_older_result;
	result = pre_result = 1;
	while (n > 2)
	{
		n -= 1;
		next_older_result = pre_result;
		pre_result = result;
		result = pre_result + next_older_result;
	}
	return result;
}

注:

1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。

2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。

3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。