C语言之初识函数
目录
1.函数是什么
在维基百科中函数的定义：子程序。
在计算机科学中，子程序是一个大型程序中的部分代码，是一个或多个语句块组成。它负责某块特定任务，相对于其它代码而言，具有相对的独立性。
一般会有输入参数并有返回值，提供对过程的分装和隐藏，这些代码通常被集成为软件库。
2.库函数
库函数，那库函数为什么要存在呢？为什么要有库函数呢？
1.就比如说我们在编写C程序是要频繁的输出某一个结果，想要把这个结果打印到我们的电脑屏幕上，这个时候我们就需要用到printf函数，即将信息按照某一个是打印到我们的屏幕上。
2.再比如说我们要求一个数的开平方根，这时候我们就需要用到sqrt函数。
3.在编程时我们有时也需要计算n的k次方，这是我们就可以用pow函数。
类似于上面我们要实现某些特定的功能，它们并不是业务性的代码，我们在开发的过程中每个程序员都有可能用的到，甚至是频繁的使用，为了提高可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似上述的库函数，方便程序员进行软件开发。
所以，我们如果想实现一些功能时，直接调用库函数就可以了，人家库函数已经为我们准备好了，就不需要我们自已编写程序来实现特定的功能了。
下面举一些C语言常用的库函数：
IO函数 input output函数
字符串操作函数 strlen strcmp
内存操作函数 memcpy memmove memset
时间/日期函数 time
数字函数 sqrt pow
其他库函数
下面是学习库函数的一些网站：
www.cplusplus.com
https://en.cppreference.com （英文版）
https://zh.cppreference.com （中文版）
3.自定义函数
刚刚提到了库函数，但是库函数中的功能毕竟是有限的，是有局限的，它不可能解决我们所有需要的功能，所以说如果库函数能解决所有问题，那我们程序员是来干什么的呢？这个时候就需要自定义函数了，即自已编写一个函数使其能够实现特定的功能。自定义函数和函数名一样，有函数名、返回值类型、函数参数。
函数的组成：
ret_type fun_name(paral, *)
{
statment;//语句项
}
ret_type 返回类型
fun_name 函数名
paral 函数参数
下面我们要写一个函数要求两个数中的最大值，请看：
#include<stdio.h>
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);
int max = get_max(a, b);
printf("max=%dn", max);
return 0;
}
当然我们也可以把上述代码简化一些：
#include<stdio.h>
int get_max(int x, int y)
{
return (x > y ? x : y);
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int max = get_max(a, b);
printf("max=%dn", max);
return 0;
}
再来举一个简单的例子：
#include<stdio.h>
void test()
{
printf("asfn");
}
int main()
{
test();
return 0;
}
上述代码中的void的什么意思呢？我们还是拿代码来举例：
现在，我们想写一个swap函数来实现两个数的交换，我们这么写可不可以呢？请看：
#include<stdio.h>
void swap(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 10;
int b = 20;
swap(a, b);
printf("a=%d,b=%dn", a, b);
return 0;
}
如果你认为上述的代码可是实现a和b的交换，即交换之后的结果应该是a变为20，而b变为10，但结果真是如此吗？请看运行结果：
我们会惊奇的发现，忙活了半天但是我们写的swap函数好像并没有起到交换的作用，即我们写出来一个bug，只能说明我们写的代码有问题。
我们先通过调试看看能不能找这其中的问题：
我们可以发现a，b的地址和x，y的地址不相同。即a,b,x,y都拥有属于自己的一块内存空间，我们只是把a和b的值通过swap函数传给了x，y后，把x，y中的值进行了交换，既然是把x，y的值进行了交换，那么就对a，b没有产生任何影响。
在这里我们把a和b叫做实参，即实际参数，而x和y叫做形式参数，但我们把实参a和b的值传给形参后，不要忘了形式参数x和y也拥有属于自己的一块空间，所以改变形参（在这里指的是交换x和y的值）不会对实参产生任何的影响。因此当函数调用的时候，实参传给形参，这时形参是实参的一份临时拷贝，对形参的修改不影响实参。
既然上述代码不能实现两数交换的话，那我们不妨还一种思路（通过地址的方式（指针）将两者之间建立联系），在这之前先看一段代码：
所以，我们可以通过地址的方式将两者之间建立联系。请看代码：
***相当于我们可以通过地址的方式，从swap函数中远程的操作主函数中a和b的值。***但是要注意a和b的地址肯定是没有变的，只不过是把a和b的地址所指向空间的内容改变了。
所以，那以后什么情况下我们需要把地址传过去呢？当这个函数内部可能会改变主函数中某些信息的时候，此时我们就可以把地址传过去，记住这种思路。
4.函数参数
4.1实际参数（实参）
真是传递给函数的参数叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传递给形参。
4.2形式参数（形参）
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。
形式参数当函数调用完成之后就被销毁了。因此形式参数只有在函数中有效。
还是以下面代码为例：
#include<stdio.h>
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);
int max = get_max(a, b);
printf("max=%dn", max);
return 0;
}
那么请问形式参数x和y会不会占用内存空间呢？
只有当我们调用get_max函数时，我们才会给形式参数x和y分配空间，在调用get_max函数之前，形式参数x和y是不会占用空间的，它只是形式上存在而已。
另外补充一点：形参实例化的意思就是当我们把实参的值传递给形参并且创建形参的这个过程（也可以理解为为形式参数创建空间的过程）叫做形参实例化。实参实例化之后其实相当于实参的一份临时拷贝。
5.函数调用
5.1传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
5.2传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外部的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
5.3练习
写一个函数求100到200之间的素数：
#include<stdio.h>
#include<math.h>
int isprime(int n)
{
for (int j = 2; j <= sqrt(n); j++)
{
if (n % j==0)
return 0;
}
return 1;
}
int main()
{
for (int i = 100; i <= 200; i++)
{
//判断是否为素数，是则返回1，否则返回0
if (isprime(i))
{
printf("%d ", i);
}
}
return 0;
}
写一个函数判断一年是不是闰年：
#include<stdio.h>
int is_leap_year(int n)
{
//是闰年返回1，不是闰年返回0
if (n % 4 == 0 && n % 100 != 0 || n % 400 == 0)
return 1;
else
return 0;
}
int main()
{
for (int i = 1000; i <= 2000; i++)
{
if (is_leap_year(i))
printf("%d ", i);
}
return 0;
}
写一个函数，实现一个整型有序数组的二分查找(也称为折半查找)：
#include<stdio.h>
int binary_search(int arr[], int k, int sz)
{
int left = 0;
int right = sz - 1;
while (left <= right)
{
int mid = (left + right) / 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,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int k = 8;
//如果能找到就返回下标，找不到则返回-1
int ret = binary_search(arr, k, sz);
if (ret == -1)
printf("找到了n");
else
printf("找到了，下标为%d", ret);
return 0;
}
写一个函数，每调用一次这个函数，num的值就加1：
方式一：
#include<stdio.h>
void Add(int* p)
{
*p = *p + 1;
}
int main()
{
int num = 0;
Add(&num);
printf("%dn", num);
Add(&num);
printf("%dn", num);
Add(&num);
printf("%dn", num);
return 0;
}
方式二：
#include<stdio.h>
int Add(int n)
{
return n + 1;
}
int main()
{
int num = 0;
num = Add(num);
printf("%dn", num);//1
num = Add(num);
printf("%dn", num);//2
num = Add(num);
printf("%dn", num);//3
return 0;
}
6.函数的嵌套调用和链式访问
6.1嵌套调用
程序都是由函数组成的。
函数和函数之间可以根据实际的需求进行相互的组合，也就是嵌套调用。
举一个简单例子：
#include<stdio.h>
void new_line(void)
{
printf("hehen");
}
void three_line(void)
{
for (int i = 1; i <= 3; i++)
{
new_line();
}
}
int main()
{
three_line();
return 0;
}
再来举个小例子：
#include<stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));//4321
return 0;
}
7.函数的声明和定义
7.1函数声明
1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么，但是具体该函数存不存在，不是由函数声明决定的。
2.函数的声明一般出现在函数的使用之前，要满足先声明后使用。
3.函数的声明一般要放在头文件中。
在有些书中，是这样写的：
在这里再次强调上述代码是不规范，不正确的。尽管程序能够运行起来。当上述程序运行起来时，编译器会爆出警告：即Add未定义，那为什么会出现这样的警告呢？是这样的：***因为代码在进行编译时，要进行代码的扫描，而代码进行扫描时是从前往后进行扫描的。***所以说，当我们先用函数而后进行函数声明时，编译器就会进行警告。
故，我们应该这样来写代码（即先进行函数声明和定义，而后使用）：
#include<stdio.h>
//函数的声明
int Add(int x, int y);//注意不要丢掉分号
int main()
{
int a = 10;
int b = 20;
int ret = Add(a, b);
printf("ret=%dn", ret);
return 0;
}
//函数的定义
//函数的声明是一种特殊的函数定义
int Add(int x, int y)
{
return x + y;
}
也可以这样：
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
int ret = Add(a, b);
printf("ret=%dn", ret);
return 0;
}
但是实际上呢，函数的声明和定义不是这样来使用的，上述代码和举例只是我们的一个语法展示，那么真正在工程中函数的声明和定义应该是怎样用的呢？比如：
这与变量的声明和定义有着相似之处，比如：
所以，一般函数的声明放到.h头文件中，而具体函数的实现（也可以说函数的定义）放到.c的头文件中去。这才是函数的声明和定义应该有的一种形式。
***那为什么要这么麻烦把.h和.c文件分开写呢？，其一是方便模块化开发，其二是代码的隐藏。
总结：函数的声明放到.h头文件中，函数的定义(或函数的实现)单独放到.c源文件中。在未来遇到稍微复杂的代码我们就可以分文件去写。
8.函数递归
8.1什么是递归？
程序调用自身的编辑技巧称为递归(recursion)，可以简单理解为自己调用自己。
递归作为一种算法在程序设计语言中广泛应用，一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
递归策略：只需少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了代码量。
递归的主要思考方式：把大事化小。
举一个很容易理解的递归：
只不过是这个递归陷入死循环了，所以说这是一个错误的递归，最终这个程序会因为栈溢出导致崩溃而停止运行。
8.2递归的两个必要条件
1.存在限制条件，当满足这个限制条件时，递归不再继续。
2.每次递归调用之后越来越接近这个限制条件。
8.2.1练习
接受一个整型值（无符号），按照顺序打印它的每一位。
例如输入：1234
输出：1 2 3 4
#include<stdio.h>
void Print(n)
{
if (n > 9)
{
Print(n / 10);
}
printf("%d ", n % 10);
}
int main()
{
unsigned int num = 0;
scanf("%d", &num);
//写一个函数把num的每一位打印出来
Print(num);
return 0;
}
我们发现每次递归都会接近n>9这个限制条件，所以递归最终会停下来。
下面再来看一个练习：编写函数不允许创建临时变量，求字符串长度
#include<stdio.h>
int my_strlen(char* str)
{
int count = 0;
while (*str != '')
{
count++;
str++;//字符指针+1，先后跳一个字符
}
return count;
}
int main()
{
char arr[] = "helloworld";
int len = my_strlen(arr);
printf("len=%d", len);
return 0;
}
但是题目要求是不创建临时变量，而上述代码创建了临时变量count，这个时候就得找其他方法。请看：
#include<stdio.h>
#include<string.h>
int my_strlen(char* str)
{
if (*str != '')
return 1 + my_strlen(str + 1);
else
return 0;
}
int main()
{
char arr[] = "helloworld";
int len = my_strlen(arr);
printf("len=%dn", len);
return 0;
}
我们也会发现每次调用my_strlen函数时都会接近递归条件*str!='',因此我们要熟练掌握这种思想，在今后会为我们学习提供另一种思路。
另外记住一句话：递归=递推+回归。
8.3递归与迭代
写一个函数求n的阶乘：
方式一（递归思想）：
#include<stdio.h>
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("ret=%dn", ret);
return 0;
}
方式二（迭代思想）：
#include<stdio.h>
int fac(int n)
{
int ret = 1;
for (int i = 1; i <= n; i++)
{
ret *= i;
}
return ret;
}
int main()
{
int x = 0;
scanf("%d", &x);
int ret = fac(x);
printf("ret=%dn", ret);
return 0;
}
写一个函数求第n个斐波那契数：
方式一（递归思想）不考虑溢出：
#include<stdio.h>
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("%dn", ret);
return 0;
}
在运行上述代码时，我们肯定会发现一个问题：
1.在使用fib这个函数计算第五十个斐波那契数时会特别的消耗时间。
2.在使用factorial函数求10000的阶乘时（不考虑结果的正确性），程序会崩溃。
那如何解决上述问题？
1.将递归改为非递归。
2.使用static对象代替nonstatic局部对象，在递归函数设计中，可使用static对象替代nonstatic局部对象（即栈对象），这不仅仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可用各个调用层所访问。
虽然递归可能会存在栈溢出的情况，运算速度比较慢，但递归的一个非常好的优势是它的代码少，同样一个题目如果用递归的方式可能几行就写完了，而如果用非递归的方式可能就需要大量的代码，用起来也比较复杂。
方式二（非递归）:
#include<stdio.h>
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;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = fib(n);
printf("ret=%d", ret);
return 0;
}
最后提示：
1.许多问题是以递归的形式解释的，这只是因为它比非递归的形式更为清晰。
2.但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差一些。
3.当一个问题相对复杂，或难以用迭代实现时，此时递归实现的简洁性便可以弥补它所带来的运行时开销。
函数递归经典题目（这里不展开说明）：
1.汉诺塔问题
2.青蛙跳台阶问题
最后，本文直到知道这里就结束了，望对大家的学习有所帮助。再次感谢！！！