文章目录
1. 函数是什么？
维基百科中对函数的定义：子程序
- 在计算机科学中，子程序，是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对独立性。
- 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
2.C语言中函数的分类：
- 库函数
- 自定义函数
2.1 库函数：
为什么会有库函数？
- 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
- 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
- 在编程时我们也做计算，总是会计算n的k次方这样的运算（pow）。
像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。
那么怎么学习库函数呢？
简单的总结，C语言常用的库函数都有：
- IO函数
- 字符串操作函数
- 字符操作函数
- 内存操作函数
- 时间/日期函数
- 数学函数
- 其他库函数
我们参照文档，学习几个库函数：
strcpy
char * strcpy ( char * destination, const char * source );
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "bit";//拷贝的时候连\0都要拷贝过去
char arr2[20] = "############";
strcpy(arr2, arr1);
printf("%s", arr2);
return 0;
}
打印出来的结果为啥只有bit，没有剩余#？
答：打印到\0时就停止打印了，结束打印
memset
void * memset ( void * ptr, int value, size_t num );
#include<stdio.h>
#include<string.h>
int main()
{
char arr[] = "hello word";
memset(arr, '*', 5);//memory-内存 set-设置
printf("%s", arr);
return 0;
}
注释：
使用库函数，必须包含#include对应的头文件
2.1.1 如何学会使用库函数？
需要全部记住吗？NO
需要学会查询工具的使用：
- MSDN
- www.cplusplus.com
- http://en.cppreference.com（英文版）
- http://zh.cppreference.com（中文版）
英文很重要，
起码看得懂文献。
2.2 自定义函数
如果库函数能干所有的事情，那还要程序员干什么？
所以更加重要的是自定义函数。
自定义函数和库函数一样，有函数名，返回值类型和函数参数。
但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。
函数的组成：
ret_type fun_name( para1, * )
{
statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数
举个例子：
写一个函数可以找出两个整数中的最大值。
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 = %d", max);
return 0;
}
再举个例子：
写一个函数可以交换两个整形变量的内容。
int Swapl(int x, int y)//这个地方不要写“；”
{
int temp = 0;
temp = x;
x = y;
y = temp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
Swapl(a, b);
printf("a = %d, b = %d", a, b);
return 0;
}
结果是a和b的值没有被交换
因为a, b, x, y是四个不同的变量，四个不同的存储空间，地址不同
于是得用指针
修改：
int Swap1(int x, int y)//这个地方不要写“；”
{
int temp = 0;
temp = x;
x = y;
y = temp;
}
int Swap2(int* pa, int* pb)//这个地方不要写“；”
{
int temp = 0;
temp = *pa;
*pa = *pb;
*pb = temp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
Swap1(a, b);
printf("a = %d, b = %d", a, b);
Swap2(&a, &b);
int* pa = &a;
int* pb = &b;
printf("a = %d, b = %d", a, b);
return 0;
}
3.函数的参数
3.1 实际参数（实参）：
真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的参数，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
3.2 形式参数（形参）
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才
实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动
销毁了。因此形式参数只有函数中有效。
上面Swap1和Swap2函数中的参数x, y, pa, pb都是形式参数
在main函数中传给Swap1的a, b和传给Swap2函数的&a, &b是实际参数
Swap1函数在调用时，x, y拥有自己的空间，同时拥有了和实参一模一样的内容。
所以我们可以简单的认为：实参实例化之后其实相当于实参的一份临时拷贝
4. 函数的调用：
4.1 传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
4.2 传址调用
- 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
- 这种传参方式可以让函数和函数外部的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
4.3 练习
1.写一个函数判断一个数是不是素数
#include<math.h>
int is_prime(int n)//是素数就返回一，不是就返回二
{
int j = 0;
for (j = 2; j <= sqrt(n); j++)//j < n 可优化成 j <= sqrt(n)
{ //则要加上#include<math.h>
if (n % j == 0)
return 0;
}
return 1;
}
int main()
{
int i = 0;
for (i = 100; i <= 200; i++)
{
if (is_prime(i) == 1)
printf("%d ", i);
}
return 0;
}
2.写一个函数判断一年是不是闰年
int is_leap_year(x)
{
if ((x % 4 == 0) && (x % 100 != 0) || (x % 400 == 0))
{
return 1;
}
else
return 0;
}
int main()
{
int year = 0;
for (year = 1000; year <= 2000; year++)
{
if (1 == is_leap_year(year))
printf("%d ", year);
}
return 0;
}
3.写一个函数，实现一个整形有序数组的二分查找
int binary_search(int arr[], int k)
{
int sz = sizeof(arr) / sizeof(arr[0]);
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 k = 0;
scanf("%d", &k);
int ret = binary_search(arr, k);//找到了就返回下标，找不到就返回-1
if (ret == -1)
{
printf("找不到");
}
else
{
printf("找到了，下标是：%d", ret);
}
return 0;
}
结果是输入任何数字都显示找不到
原因：
int ret = binary_search(arr, k);//找到了就返回下标，找不到就返回-1
这里传过去的是arr数组的首元的地址，而不是整个数组
int binary_search(int arr[], int k)
本质上arr是一个指针
int sz = sizeof(arr) / sizeof(arr[0]);
求的就是指针的长度
指针长度为4（x32）为8（x64）
修改：
把sz放主函数中求，然后再传过去
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 k = 0;
scanf("%d", &k);
int sz = sizeof(arr) / sizeof(arr[0]);
int ret = binary_search(arr, k, sz);//找到了就返回下标，找不到就返回-1
if (ret == -1) //这里也要补上一个sz
{
printf("找不到");
}
else
{
printf("找到了，下标是：%d", ret);
}
return 0;
}
4.写一个函数，每调用一次这个函数，就会将num的值增加1。
void Add(int* p)//不用返回值，用void
{
(*p)++;//如果写成*p++，则是将p加1然后再*（++优先级高于*），所以要加括号
}
int main()
{
int num = 0;
Add(&num);//改变值就得用到地址（取地址符号）和指针
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
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 链式访问
把一个函数的返回值作为另外一个函数的参数。
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
}
打印出来的结果：4321
从内向外打印
先打印printf("%d", 43)打印43
然后printf函数的返回值是打印的字符的个数
所以printf("%d", 43)的返回值是2
接着printf("%d", 2)打印2
返回1，printf("%d", 1)打印1
总共打印4321
6. 函数的声明和定义
6.1 函数声明：
- 告诉编译器有一个函数叫什么，参数叫什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
- 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
- 函数的声明一般要放在头文件中。
6.2 函数定义：
函数的定义是指函数的具体实现，交代函数的功能实现。
test.h的内容
放置函数的声明
#ifndef __TEST_H__ //if not define 两个下划线然后就是自己起的名字大写一个下划线，然后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;
}
引用自己写的头文件用“ ”,比如：
#include"add.h"
这种分文件的书写形式，在三子棋和扫雷的时候，再具体说分模块来写。
7. 函数递归
7.1 什么是递归？
程序调用自身的编程技巧称为递归（recursion）。
递归做为一种算法在程序设计语言中广泛应用。
一个过程或函数在定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂问题层层转化为一个与原问题相似的规模较小的问题来求解。
递归策略只需少量的程序就可描述出解题过程中所需要的多次重复计算，大大减少了程序的代码量。
递归的主要思考方式在于：把大事化小
7.2 递归的两个必要条件
- 存在限制条件，当满足这个限制条件的时候，递归便不在继续。
- 每次递归调用之后越来越接近这个限制条件。
7.2.1 练习1：
接受一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：1234，输出：1 2 3 4
void print(int n)
{
if (n > 9)
{
print(n / 10);//递归，再次调用print函数
}
printf("%d ", n % 10);
}
int main()
{
int num = 0;
scanf("%d", &num);
print(num);//这里是函数，不是输出关键词printf
return 0;
}
7.2.2 练习2：
编写函数不允许创建临时变量，求字符串长度。
如果创建临时变量怎么写？
如下：
#include<string.h>
int my_strlen(char* str)//str就是个指针变量
{
int count = 0;
while (*str != '\0')
{
count++;
str++;//让地址加，数组中每个元素的地址都是连续的
}
return count;
}
int main()
{
char arr[] = "bit";
//现在要模拟实现strlen函数
int len = my_strlen(arr);//arr是数组，数组传参，传过去的不是整个数组，而是第一个元素的地址
printf("len = %d", len);
return 0;
}
用递归写：
#include<string.h>
int my_strlen(char* str)//str就是个指针变量
{
if (*str != '\0')
{
return 1 + my_strlen(str + 1);
}
else
return 0;
}
int main()
{
char arr[] = "bit";
//现在要模拟实现strlen函数
int len = my_strlen(arr);//arr是数组，数组传参，传过去的不是整个数组，而是第一个元素的地址
printf("len = %d", len);
return 0;
}
7.3 递归与迭代
递归与迭代的区别
- 递归是不断调用自身。假设递归自己是一个函数的话，那递归的返回值会当作参数再次传入自身。
- 迭代是将某一个初值设定，不断放入某一个循环体，得到的值成为一个新值再次放入循环体中，通过循环体中的操作，逐步得到我们想要的结果。
- 总结一下就是：程序调用自身称为递归，利用变量的原值推出新值称为迭代。
- 递归中一定有迭代,但是迭代中不一定有递归,大部分可以相互转换，少部分只能用迭代，很难用递归。
递归与迭代的区别参考于：
原文链接：https://blog.csdn.net/shuiyixin/article/details/83188384
7.3.1 练习3：
求n的阶乘。（不考虑溢出）
循环写：
int Fac1(int n)
{
int i = 0;
int ret = 1;
for (i = 1; i <= n; i++)
{
ret *= i;
}
return ret;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac1(n);//循环方式
printf("%d\n", ret);
return 0;
}
递归写：
int Fac2(int n)
{
if (n <= 1)
return 1;
else
return n * Fac2(n - 1);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac2(n);
printf("%d\n", ret);
return 0;
}
7.3.2 练习4：
求第n个斐波那契数。（不考虑溢出）
int Fib(int n)
{
if (n <= 2)
return 1;
else
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d", &n);//n代表第几个斐波那契数（1，1，2，3，、、、）
ret = Fib(n);
printf("%d", ret);
return 0;
}
但是用迭代的方式求斐波那契数太慢了，因为有很多重复工作
50
49 48
48 47 47 46
47 46 46 45 46 45 45 44
用循环解决会更好
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;//当n=1或2时不进入循环，直接返回c
while (n > 2)
{
c = a + b;
a = b;
b = c;
n--;
}
return c;
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d", &n);//n代表第几个斐波那契数（1，1，2，3，、、、）
ret = Fib(n);
printf("%d", ret);
return 0;
}
3114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
