一.函数定义
维基百科中对函数的定义：子程序
- 在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method, subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组 成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
- 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
二.函数的分类
- 库函数
- 自定义函数
1.库函数
为什么会有库函数？
1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想 把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
正如我们之前讨论的那些基本功能，它们并非专门针对特定业务的代码。在编程过程中，几乎每位开发者都可能会用到它们。为了增强代码的可移植性并提升程序运行效率，C语言的标准库中包含了许多这样的库函数，旨在帮助程序员更便捷地进行软件开发。
下面我提供了学习库函数的网址，大家可以看看
https://cplusplus.com/reference/
简单的总结，C语言常用的库函数都有：
- IO函数
- 字符串操作函数
- 字符操作函数
- 内存操作函数
- 时间 / 日期函数
- 数学函数
- 其他库函数
我们参照文档，学习几个库函数：
注：
- 然而，使用库函数时需要牢记的一个重要事项是：必须引入相应的头文件，使用预处理指令#include。
- 通过参考相关文档来学习这些库函数，我们的目标是掌握如何正确使用这些库函数。
1.1库函数的使用
需要全部记住吗？No
需要学会查询工具的使用：
MSDN(Microsoft Developer Network)
http://en.cppreference.com（英文版）
http://zh.cppreference.com（中文版）
2.自定义函数
- 如果库函数能干所有的事情，那还要程序员干什么？
- 所有更加重要的是自定义函数。
- 自定义函数和库函数一样，有函数名，返回值类型和函数参数。
- 但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。
2.1 函数的组成
ret_type fun_name(para1, *)
{
statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数
2.2 举例
写一个函数求两个数的较大者
#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 m = get_max(a,b);
printf("%d\n", m);
return 0;
}写一个函数交换两个整型变量的内容
#include <stdio.h>
//实现成函数，但是不能完成任务
//void Swap(int x, int y)//x,y是形参
//{
// int z = 0;
// z= x;
// x = y;
// y = z;
//}//仅仅交换了x，y，并没有将a,b相交换
//
//当实参的传递给形参的时候，形参是实参的一份临时拷贝
//对形参的修改不会影响实参的改变
//
//正确的版本
void Swap(int* px, int* py)
{
int z = 0;
z = *px;
*px = *py;
*py = z;
}//传输地址才能正确找到需要操作的数字
int main()
{
int num1 = 0;
int num2 = 0;//num1,num2是实参
scanf("%d %d", &num1, &num2);
printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
Swap(&num1, &num2);
printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
return 0;
}三.函数的参数
1.实际参数(实参)
- 真实传给函数的参数，叫实参。
- 实参可以是：常量、变量、表达式、函数等。
- 无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
2.形式参数(形参)
- 形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。
- 形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
四.函数的调用
1.传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
2.传址调用
- 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
- 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
3.练习
1.写一个函数可以判断一个数是不是素数。
2.写一个函数判断一年是不是闰年。
3.写一个函数，实现一个整形有序数组的二分查找。
4.写一个函数，每调用一次这个函数，就会将 num 的值增加1。
代码1：(遍历实现)
#include<stdio.h>
#include<math.h>
int main()
{
int i = 0;
int count = 0;
//for (i = 100;i <= 200;i++)
for (i = 101;i <= 200;i += 2)
{
int flag = 1;
int j = 0;
//for (j = 2;j < i - 1;j++)
for (j = 2;j < sqrt(i);j++)
{
if (i % j == 0)
{
flag = 0;
break;
}
}
if (flag == 1)
{
printf("%d ", i);
}
}
return 0;
}
代码1：(函数实现)
#include <stdio.h>
#include <math.h>
int is_prime(int n)
{
int j = 0;
//for (j = 2;j <= i - 1;j++)
for (j = 2;j <= sqrt(n);j++)
{
if (n % j == 0)
{
return 0;
}
}
return 1;
}
int main()
{
int i = 0;
int count = 0;
//for (i = 100;i <= 200;i++)
for (i = 101;i <= 200;i += 2)
{
if (is_prime(i))
{
printf("%d ", i);
count++;
}
}
printf("\ncount=%d", count);
return 0;
}
代码2：(直接实现，不用函数)
int main()
{
int year = 0;
printf("1000到2000之间的闰年:\n");
for (year = 1000;year <= 2000;year++)
{
if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
{
printf("%d ", year);
}
}
return 0;
}
代码2：(函数实现)
#include<stdio.h>
int is_leap_year(int year)
{
if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
{
return 1;
}
return 0;
}
int main()
{
int year = 0;
int count = 0;
printf("1000到2000之间的闰年:\n");
for (year = 1000;year <= 2000;year++)
{
if (is_leap_year(year))
{
printf("%d ", year);
count++;
}
}
printf("\ncount=%d", count);
return 0;
}代码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 - left) / 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 = 7;
int sz = sizeof(arr) / sizeof(arr[0]);
//找到了返回下标
//找不到返回-1
int ret = binary_search(arr, k, sz);
if (ret == -1)
{
printf("找不到\n");
}
else
{
printf("找到了，下标是%d\n", ret);
}
return 0;
}代码4：(第一种)
#include<stdio.h>
int Add(int n)
{
return n+1;
}
int main()
{
int num = 0;
num = Add(num);
printf("%d ", num);
num = Add(num);
printf("%d ", num);
num = Add(num);
printf("%d ", num);
return 0;
}代码4：(第二种)
#include<stdio.h>
void Add(int* p)
{
(*p)++;
}
int main()
{
int num = 0;
Add(&num);
printf("%d ", num);
Add(&num);
printf("%d ", num);
Add(&num);
printf("%d ", num);
return 0;
}五.函数的嵌套调用和链式访问
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
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;
}函数可以嵌套调用，但是不能嵌套定义。
2.链式访问
把一个函数的返回值作为另外一个函数的参数。
#include <stdio.h>
#include <string.h>
int main()
{
char arr[20] = "hello";
int ret = strlen(strcat(arr, "bit"));//这里介绍一下strlen函数
printf("%d\n", ret);
return 0;
}
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
//结果是啥？
//注：printf函数的返回值是打印在屏幕上字符的个数
return 0;
}
六.函数的声明与定义
1.函数声明
1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。
2.函数定义
函数的定义是指函数的具体实现，交待函数的功能实现。
#include<stdio.h>.
int main()
{
int a = 0;
int b = 0;
scanf("%d %d",&a,&b);
//加法
int sum = Add(a,b);
printf("%d",sum);
return 0;
}//函数的定义
int Add(int x, int y)
{
return (x + y);
}注：正如上面的例子，一般来说，函数定义要放在主前面，虽然代码也能跑起来但是会报错
若是想放在后面也可以，但是要进行函数的声明
//函数的声明
int Add(int x , int y);//函数的返回类型，函数名称，函数返回参数类型和函数保持一致
int main()
{
int a = 0;
int b = 0;
scanf("%d %d",&a,&b);
//加法
int sum = Add(a,b);
printf("%d",sum);
return 0;
}//函数的定义
int Add(int x, int y)
{
return (x + y);
}//这样程序就不会报错
3.函数模块化设计
上述代码也可以使用模块化编程,如下：
add.h
//函数的声明
int Add(int x, int y);
add.c
//函数的定义
int Add(int x, int y)
{
return (x + y);
}
上面合称为加法模块
主函数：
#include<stdio.h>
#include "add.h"//引用了add.h，就可以用add模块里面的程序
int main()
{
int a = 0;
int b = 0;
scanf("%d %d",&a,&b);
//加法
int sum = Add(a,b);
printf("%d",sum);
return 0;
}
七.函数递归
1.递归的定义
- 程序调用自身的编程技巧称为递归（ recursion）。
- 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的
- 一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略
- 只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
- 递归的主要思考方式在于：把大事化小。
2.递归的两个必要条件
- 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
- 每次递归调用之后越来越接近这个限制条件
3.练习
1.接受一个整型值（无符号），按照顺序打印它的每一位。
例如： 输入：1234，输出 1 2 3 4
#include <stdio.h>
void print(unsigned int n)
{
if (n > 9)
{
print(n / 10);
}
printf("%d ", n % 10);
}
int main()
{
unsigned int num = 0;
scanf("%u ",&num);
print(num);
return 0;
}
2.编写函数不允许创建临时变量，求字符串的长度。
#include <stdio.h>
int my_strlen(char* str)
{
if (*str != '\0')
{
return 1 + my_strlen(str+1);
}
else
{
return 0;
}
}
int main()
{
char arr[] = "abc";
//char*
int len = my_strlen(arr);
printf("%d\n",len);
return 0;
}
3.求n的阶乘
方法一：递归实现（不考虑溢出）
#include<stdio.h>
int fac(int n)
{
if (n <= 1)
return 1;
else
return n * fac(n - 1);
}int main()
{
int n = 0;
scanf("%d", &n);
int ret = fac(n);
printf("ret = %d\n", ret);
return 0;
}
方法二：迭代实现
#include<stdio.h>
int fac(int n)
{
int i = 0;
int ret = 1;
for (i = 1;i <= n;i++)
{
ret = ret * i;
}
return ret;
}int main()
{
int n = 0;
scanf("%d", &n);
int ret = fac(n);
printf("ret = %d\n", ret);
return 0;
}
4.求第n个斐波那契数。（不考虑溢出）
方法1：递归实现
#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("ret=%d\n", ret);
return 0;
}
但是在使用递归我们会发现：
- 在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
- 使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
原因：我们发现 fib 函数在调用的过程中很多计算其实在一直重复。
方法2：迭代实现
#include <stdio.h>
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while (n >= 3)
{
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\n", ret);
return 0;
}//上述代码用迭代实现效率更高，避免了重复的过程
注：
1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。
扫一扫
5795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
