1.前言
Hello，大家好，我是小陈，新年快乐呀！马上就龙年了，今天是大年30，祝各位新的一年更上一层楼，今天小陈为大家带来了C语言的函数基础知识，希望大家仔细看完。
2.函数的概念
何为函数呢？我们在之前的数学学习中知道，例如y=kx+b，y=x^等这样的函数，因变量与自变量，当然在C语言的函数中也是这样，求解一些复杂的简单的编程问题，我们可以用函数去解决，比如计算很大的数字，大数据的处理，其实就是C语言中的函数就是一个完成某项特定的任务的一小段代码，为子程序。
3.库函数与自定义函数
3.1标准库与头文件
库函数就是C语言仓库里的函数，内置函数，而标准库可以通俗的解释为为程序员提供用的函数。
库函数相关头文件：zh.cppreference.com/w/c/header
3.2库函数的使用方法
C/C++官方的链接:zh.cppreference.com/w/c/header
cplusplus.com:legacy.cplusplus.com/reference/c…
举例:sqrt
double sqrt (double X);
//sqrt是函数名
//x 是函数的参数，表示调用sqrt函数需要传递一个double的类型的值
//double 是返回值类型 - 表示函数计算的结果是double类型的值
//总的来说就是函数返回类型+函数名+函数参数的类型+传参的值。
//这个函数的功能就是计算平方根和返回平方根
//在使用库函数的时需要包含头文件
//这个函数的实践
#include <stdio.h>
int main()
{
double d =16.0;
double r = sqrt(d);
printf("%lf\n",r);
return 0
}
3.3库函数文档的一般格式
1.函数原型
2.函数功能介绍
3.参数和返回类型说明
3.4自定义函数
语法形式
ret_type fun_name(形式参数)
{
}
ret_type 是函数返回类型
fun_name 是函数名
括号中放的是形式参数
{}括起来的是函数体
在这个图中我们可以清晰的知道自定义函数如何使用，但是要注意以下两点:
1.尽量起有意义的函数名字，比如加法Add
2.函数返回类型要确定好，接受的参数类型和传参的参数类型要相同。
函数举例：
写⼀个加法函数，完成2个整型变量的加法操作。
#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
//输⼊
scanf("%d %d", &a, &b);
//调⽤加法函数，完成a和b的相加
//求和的结果放在r中
//to do
//输出
printf("%d\n", r);
return 0;
}
写出Add函数
#include <stdio.h>
int Add(int x, int y)
{
int z = 0;
z = x+y;
return z;
}
int main()
{
int a = 0;
int b = 0;
//输⼊
scanf("%d %d", &a, &b);
//调⽤加法函数，完成a和b的相加
//求和的结果放在r中
int r = Add(a, b);
//输出
printf("%d\n", r);
return 0;
}
//可以简化为:
int Add(int x, int y)
{
return x+y;
}
4.形参和实参
4.1实参
实参可以理解为它在main函数里的参数，因为如果想调用一个子程序，也就是函数我们通常会把函数写在main函数外，这样可以在main函数里写实参，传递给子程序。
4.2形参
在上面的代码里，如果只是定义了 Add 函数，⽽不去调⽤的话， Add 函数的参数 x 和 y 只是形式上存在的，不会向内存申请空间，不会真实存在的，所以叫形式参数。形式参数只有在 函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，当实参已经确定，字母是不可以发生变化，参数类型也是，而传递过去的实参，参数类型必须和形参一样，否则就会引起类型不兼容问题，这个过程就是形式的实例化。
4.3 实参和形参的关系
虽然我们提到了实参是传递给形参的，他们之间是有联系的，但是形参和实参各⾃是独⽴的内存空间。
#include <stdio.h>
int Add(int x, int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int a = 0;
int b = 0;
//输⼊
scanf("%d %d", &a, &b);
//调⽤加法函数，完成a和b的相加
//求和的结果放在r中
int r = Add(a, b);
//输出
printf("%d\n", r);
return 0;
}
我们可以理解为形参是实参的一份临时拷贝。
5. return 语句
**在函数的设计中，函数中经常会出现return语句，这⾥讲⼀下return语句使⽤的注意事项。 **
• return后边可以是⼀个数值，也可以是⼀个表达式，如果是表达式则先执⾏表达式，再返回表达式 的结果。
** • return后边也可以什么都没有，直接写 return; 这种写法适合函数返回类型是void的情况。**
** • return返回的值和函数返回类型不⼀致，系统会⾃动将返回的值隐式转换为函数的返回类型。**
** • return语句执⾏后，函数就彻底返回，后边的代码不再执⾏，如果一个程序写完了，把return 0;放在最前面则这个程序会直接退出，后面的代码不会去运行。**
**• 如果函数中存在if等分⽀的语句，则要保证每种情况下都有return返回，否则会出现编译错误。 **
6.数组做函数参数
#include <stdio.h>
int main()
{
int arr[]={1,2,3,4,5,6,7,8,9,10};
set_arr();
print_arr();
return 0;
}
set_arr函数要能对够数组内容进行设置，就得把数组作为参数传递给参数，同时函数内部设置数组每个元素的时候进行遍历数组，print_arr也是这样。
函数传参的重点知识：
• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组，形参也是可以写成数组形式的
• 形参如果是⼀维数组，数组⼤⼩可以省略不写
• 形参如果是⼆维数组，⾏可以省略，但是列不能省略
• 数组传参，形参是不会创建新的数组的
• 形参操作的数组和实参的数组是同⼀个数组
void set_arr(int arr[], int sz)
{
int i = 0;
for(i=0; i<sz; i++)
{
arr[i] = -1;
}
}
void print_arr(int arr[], int sz)
{
int i = 0;
for(i=0; i<sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
7.函数的嵌套调用和链式访问
7.1 嵌套调⽤
嵌套调用就是函数之间的互相调用，多个函数调用起来才能实现强大的功能，实现程序的调动
例如：
假设我们计算某年某⽉有多少天？如果要函数实现，可以设计2个函数:
• is_leap_year()：根据年份确定是否是闰年
• get_days_of_month()：调⽤is_leap_year确定是否是闰年后，再根据⽉计算这个⽉的天数
int is_leap_year(int y)
{
if(((y%4==0)&&(y%100!=0))||(y%400==0))
return 1;
else
return 0;
}
int get_days_of_month(int y, int m)
{
int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int day = days[m];
if (is_leap_year(y) && m == 2)
day += 1;
return day;
}
int main()
{
int y = 0;
int m = 0;
scanf("%d %d", &y, &m);
int d = get_days_of_month(y, m);
printf("%d\n", d);
return 0;
}
这⼀段代码，完成了⼀个独⽴的功能。代码中反应了不少的函数调⽤：
• main 函数调⽤ scanf 、 printf 、 get_days_of_month
• get_days_of_month 函数调⽤ is_leap_year
我们这里看到几个函数调用后实现了强大的功能，但是函数是不能被嵌套定义的！！！
7.2 链式访问
所谓链式访问就是将⼀个函数的返回值作为另外⼀个函数的参数，像链条⼀样将函数串起来就是函数 的链式访问。
#include <stdio.h>
int main()
{
int len = strlen("abcdef");//1.strlen求⼀个字符串的⻓度
printf("%d\n", len);//2.打印⻓度
printf("%d\n", strlen("abcdef");
return 0;
}
有趣的代码？
include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
}
这三层最里面的一层先打印43，然后43被确定为两个字符，再打印2，然后2被确定为1个字符，再打印为1
8. 函数的声明和定义
8.1 单个⽂件
⼀般我们在使⽤函数的时候，直接将函数写出来就使⽤了。 ⽐如：我们要写⼀个函数判断⼀年是否是闰年。
函数的定义在函数调⽤之前
#include <stido.h>
//判断⼀年是不是闰年
int is_leap_year(int y)
{
if(((y%4==0)&&(y%100!=0)) || (y%400==0))
return 1;
else
return 0;
}
int main()
{
int y = 0;
scanf("%d", &y);
int r = is_leap_year(y);
if(r == 1)
printf("闰年\n");
else
printf("⾮闰年\n");
return 0;
}
函数的定义在函数的调⽤之后
#include <stido.h>
int main()
{
int y = 0;
scanf("%d", &y);
int r = is_leap_year(y);
if(r == 1)
printf("闰年\n");
else
printf("⾮闰年\n");
return 0;
}
//判断⼀年是不是闰年
int is_leap_year(int y)
{
if(((y%4==0)&&(y%100!=0)) || (y%400==0))
return 1;
else
return 0;
}
我们发现会报错，因为函数需要先声明后使用， 函数的调⽤⼀定要满意，先声明后使⽤； 函数的定义也是⼀种特殊的声明，所以如果函数定义放在调⽤之前也是可以的。
8.2 多个⽂件
⼀般情况下，函数的声明、类型的声明放在头⽂件（.h）中，函数的实现是放在源⽂件（.c）⽂件中。
//函数的定义
int Add(int x, int y)
{
return x+y;
}
//函数的声明
int Add(int x, int y);
#include <stdio.h>
#include "add.h"
int main()
{
int a = 10;
int b = 20;
//函数调⽤
int c = Add(a, b);
printf("%d\n", c);
return 0;
}
8.3 static 和 extern
static 和 extern 都是C语⾔中的关键字。
static 是 静态的 的意思，可以⽤来：
** • 修饰局部变量 **
• 修饰全局变量
** • 修饰函数 **
extern 是⽤来声明外部符号的。
** 作⽤域和⽣命周期 **
作⽤域（scope）是程序设计概念，通常来说，⼀段程序代码中所⽤到的名字并不总是有效（可⽤）
的，⽽限定这个名字的可⽤性的代码范围就是这个名字的作⽤域。
- 局部变量的作⽤域是变量所在的局部范围。
- **全局变量的作⽤域是整个⼯程（项⽬）。
**⽣命周期指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的⼀个时间段。 - 局部变量的⽣命周期是：进⼊作⽤域变量创建，⽣命周期开始，出作⽤域⽣命周期结束。
- 全局变量的⽣命周期是：整个程序的⽣命周期。
8.3.1 static 修饰局部变量：
//代码1
#include <stdio.h>
void test()
{
int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for(i=0; i<5; i++)
{
test();
}
return 0;
}
//代码2
#include <stdio.h>
void test()
{
//static修饰局部变量
static int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for(i=0; i<5; i++)
{
test();
}
return 0;
}
对⽐代码1和代码2的效果，理解 static 修饰局部变量的意义。
** 代码1**的test函数中的局部变量i是每次进⼊test函数先创建变量（⽣命周期开始）并赋值为0，然后 ++，再打印，出函数的时候变量⽣命周期将要结束（释放内存）。
代码2中，我们从输出结果来看，i的值有累加的效果，其实 test函数中的i创建好后，出函数的时候是 不会销毁的，重新进⼊函数也就不会重新创建变量，直接上次累积的数值继续计算。
**结论：**static修饰局部变量改变了变量的⽣命周期，⽣命周期改变的本质是改变了变量的存储类型，本来⼀个局部变量是存储在内存的栈区的，但是被 static 修饰后存储到了静态区。存储在静态区的变 量和全局变量是⼀样的，⽣命周期就和程序的⽣命周期⼀样了，只有程序结束，变量才销毁，内存才 回收。但是作⽤域不变的。
8.3.2 static 修饰全局变量
代码1
int g_val = 2018;
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
代码2
static int g_val = 2018;
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
** extern **是⽤来声明外部符号的，如果⼀个全局的符号在A⽂件中定义的，在B⽂件中想使⽤，就可以使 ⽤ extern 进⾏声明，然后使⽤。
代码1正常，代码2在编译的时候会出现链接性错误。
结论： ⼀个全局变量被static修饰，使得这个全局变量只能在本源⽂件内使⽤，不能在其他源⽂件内使⽤。 本质原因是全局变量默认是具有外部链接属性的，在外部的⽂件中想使⽤，只要适当的声明就可以使 ⽤；但是全局变量被 static 修饰之后，外部链接属性就变成了内部链接属性，只能在⾃⼰所在的源 ⽂件内部使⽤了，其他源⽂件，即使声明了，也是⽆法正常使⽤的。** **
**使⽤建议：**如果⼀个全局变量，只想在所在的源⽂件内部使⽤，不想被其他⽂件发现，就可以使⽤ static修饰。
8.3.3static修饰函数
其实 static 修饰函数和 static 修饰全局变量是⼀模⼀样的，⼀个函数在整个⼯程都可以使⽤， 被static修饰后，只能在本⽂件内部使⽤，其他⽂件⽆法正常的链接使⽤了。
本质是因为函数默认是具有外部链接属性，具有外部链接属性，使得函数在整个⼯程中只要适当的声 明就可以被使⽤。但是被 static 修饰后变成了内部链接属性，使得函数只能在⾃⼰所在源⽂件内部 使⽤。
使⽤建议：⼀个函数只想在所在的源⽂件内部使⽤，不想被其他源⽂件使⽤，就可以使⽤ static 修 饰。
9.函数递归
9.1递归的定义
递归是什么？递就是递推，回就是回归，递推到结束，回归到开始，说白了就是函数自己调用自己，开始到结束调用，结束到开始调用。
#include <stdio.h>
int main()
{
printf("hehe\n");
main();//main函数中⼜调⽤了main函数
return 0;
}
这个代码只是为了演示递归的基本形式，不是为了解决问题，最终会栈溢出。
9.2如何进行递归
递归的时候就是把一个大问题拆成好多个小问题，进行计算，然后再依赖小问题的结果回归到大问题函数的本身。
9.3 递归的限制条件
• 递归存在限制条件，当满⾜这个限制条件的时候，递归便不再继续。
• 每次递归调⽤之后越来越接近这个限制条件。
9.4递归举例
举例1：求n的阶乘
:::info ⼀个正整数的阶乘（factorial）是所有⼩于及等于该数的正整数的积，并且0的阶乘为1。 ⾃然数n的阶乘写作n!。
:::
n的阶乘递归公式如下：
#include <stdio.h>
int Fact(int n)
{
if(n==0)
return 1;
else
return n*Fact(n-1);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fact(n);
printf("%d\n", ret);
return 0;
}
举例2：顺序打印⼀个整数的每⼀位
输⼊⼀个整数m，打印这个按照顺序打印整数的每⼀位 。
:::tips 1234%10就能得到4，然后1234/10得到123，这就相当于去掉了4 然后继续对123%10，就得到了3，再除10去掉3，以此类推 不断的 %10 和 /10 操作，直到1234的每⼀位都得到。
:::
void Print(int n)
{
if(n>9)
{
Print(n/10);
}
printf("%d ", n%10);
}
int main()
{
int m = 0;
scanf("%d", &m);
Print(m);
return 0;
}
9.5递归与迭代
举例3：求第n个斐波那契数
int Fib(int n)
{
if(n<=2)
return 1;
else
return Fib(n-1)+Fib(n-2);
}
#include <stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);
printf("%d\n", ret);
return 0;
}
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while(n>2)
{
c = a+b;
a = b;
b = c;
n--;
}
return c;
}
