目录
1. 函数是什么
C语言中的函数其实就是：子程序
在计算机科学中，子程序是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定的任务，而且相较于其他代码，具有相对的独立性。
一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。
2. C语言中函数的分类
1.库函数
2.自定义函数
2.1 库函数
我们描述基础功能，比如说在屏幕上打印printf，字符串拷贝strcpy等等，不是业务性的代码，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行开发。
但是库函数的使用必须要包含#include对应头文件。
2.1.1 如何学会使用库函数
不需要全部记住，但需要学会查询工具的使用
2.2 自定义函数
库函数虽然很重要，很丰富，但是并不是说能干所有的事情，其实更加重要的是自定义函数。
自定义函数和库函数一样都有函数名、返回值类型、函数参数。
但是这些都是我们自己来设计，所以说发挥空间很大。
ret_type fun_name(para1,*)
{
statement;
}
ret_type 返回类型
fun_name 函数名
para1 函数参数ex1：写一个函数找出两个整数的最大值
方法1：
int get_max(int x, int y)
{
if (x > y)
return x;
else
return y;
}
方法2：
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 m = get_max(get_max(3, 7), 5);
printf("%d\n", m);
return 0;
}ex2：写一个函数可以交换两个整形变量的内容
当函数调用的时候，实参传递给形参，这时形参是实参的一份
临时拷贝，对形参的修改不影响实参。
void swap1(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
void swap2(int *px,int *py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);//3 5
printf("交换前：a=%d b=%d\n", a, b);
swap1(a, b);
printf("交换后：a=%d b=%d\n", a, b);
swap2(&a, &b);
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}swap1交换了x，y并未交换a，b。
swap2由两指针接受地址，交换地址内的内容。
3. 函数的参数
3.1 实际参数（实参）
真实传给函数的参数叫实参
实参可以是：常量、变量、表达式、函数等。
无论何种形式的量，在进行函数调用时，都必须有确定的值，以便把这些值传给形参。
3.2 形式参数（形参）
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化，所以叫形式参数。形式参数当函数调用完成后就自动销毁了，因此形式参数只有在函数中才有效。
上面swap1，swap2中的参数x，y，px，py都是形式参数。在main函数中传给swap1的num1和num2和传给swap2函数的&num1和&num2是实际参数。
实参num1和num2与形参x，y使用的不是同一空间，swap1函数在调用时，x，y拥有自己的空间，同时拥有了和实参一样的内容。所以我们可以认为形参实例化后其实相当于实参的一份临时拷贝。
4. 函数的调用
4.1 传值调用
函数的形参与实参分别占有不同内存块，对形参的修改不会影响实参。
4.2 传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外的变量建立真正的联系，也就是函数内部可以直接操作函数外部的变量。
4.3 练习
4.3.1 判断一个数是不是素数
#include <stdio.h>
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()
{
int i = 0;
for (i = 100; i <= 200; i++)
{
if (is_prime(i))
{
printf("%d ", i);
}
}
return 0;
}4.3.2 判断一年是不是闰年
方法1：
int is_leap_year(int y)
{
if (y % 4 == 0 && y % 100 != 0)
{
return 1;
}
if (y % 400 == 0)
{
return 1;
}
return 0;
}
方法2：
int is_leap_year(int y)
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
return 1;
else
return 0;
}
方法3：
int is_leap_year(int y)
{
return (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0));
}
int main()
{
int y = 0;
for (y = 1000; y <= 2000; y+=4)
{
if (is_leap_year(y))
{
printf("%d ", y);
}
}
return 0;
}4.3.3 实现一个整形有序数组的二分查找
#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,17,18,19,20,21 };//10
int k = 21;
int sz = sizeof(arr) / sizeof(arr[0]);
int pos = binary_search(arr, k, sz);
if (-1 == pos)
printf("找不到\n");
else
printf("找到了，下标是:%d\n", pos);
return 0;
}4.3.4 写一个函数，每调用一次这个函数，num+1
void Add(int* p)
{
(*p)++;
}
int main()
{
int num = 0;
Add(&num);
printf("%d\n", num);//1
Add(&num);
printf("%d\n", num);//2
Add(&num);
printf("%d\n", num);//3
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()
{
printf("%d\n", strlen("abcdef"));
return 0;
}
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
}
printf的返回值是打印在屏幕上字符的个数6.函数的声明和定义
6.1 函数声明
1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么，但是具体是不是存在，函数声明决定不了。
2.函数声明一般出现在函数的使用之前。要满足先声明后使用。
3.函数的声明一般要放在头文件中。
6.2 函数定义
函数的定义是指函数的具体实现，交代函数的功能实现。
test.h的内容：放置函数的声明
#ifndef __TEST_H__
#define __TEST_H__
int Add(int x,int y);
#endiftest.c的内容：放置函数的实现
#include "test.h"
int Add(int x,int y)
{
return x+y;
}优点：1.模块化开发（分工）：不同功能由不同程序员开发，无法所有程序员都在同一个文件中写代码。2.代码的隐藏。
7. 函数递归
7.1 什么是递归
程序调用自身的编程技巧称为递归
递归作为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题转化为一个与原问题相似规模较小的问题来求解，递归只需要少量的程序就可以描述出解题过程需要的多次重复计算，大大减少了程序的代码量。
7.2 递归的两个必要条件
1.存在限制条件，当满足这个限制从条件时，递归便不再继续。
2.每次递归调用之后越来越接近这个限制条件。
7.2.1 练习1：
接受一个整形值，按照顺序打印它的每一位
void print(int n)
{
if(n>9)
printf(n/10);
printf("%d ",n%10);
}
int main()
{
int num = 1234;
print(num);
return 0;
}7.2.2 练习2：
编写函数不允许创建临时变量，求字符串的长度
int Strlen(const char*str)
{
if(*str=='\0')
return 0;
else
return 1+Strlen(str+1);
}
int main()
{
char *p = "ABCDEF";
int len = Strlen(p);
printf("%d\n",len);
return 0;
}7.3 递归与迭代
7.3.1 练习3：
求n的阶乘
int factorial(int n)
{
if(n<=1)
return 1;
else
return n*factorial(n-1);
}7.3.2 练习4：
求n个斐波那契数（前两个数的和为第三个数）
在使用递归时，如果求一个比较大的参数，就会报错，系统分配给程序的栈空间是有限的，但如果出现了死循环，可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这种现象称为栈溢出。
解决办法：
1.将递归改为非递归
2.使用static对象替代nonstatic局部对象。
int fib(int n)
{
int result;
int pre_result;
int next_result;
result = pre_result = 1;
while(n>2)
{
n=n-1;
next_result = pre_result;
pre_result = result;
result = pre_result+next_result;
}
return result;
}1.许多问题是以递归进行解释的，因为比非递归形式更清晰
2.但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性会降低
本章完
1417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
