请回答c语言-函数【入门】

请回答c语言-函数【入门】

请回答c语言-函数【入门】

• • 前言
• 1. 函数是什么
• 2. C语言中函数的分类：
• • 2.1 库函数：
  • • 2.1.1 学习库函数
  • 2.2 自定义函数
  • • 2.2.1 函数的组成：
    • 2.2.2 一些个栗子
• 3. 函数的参数
• • 3.1 实际参数（实参）：
  • 3.2 形式参数（形参）：
  • 3.3 理解形参与实参
• 4. 函数的调用：
• • 4.1 传值调用
  • 4.2 传址调用
  • 4.3 小练习
• 5. 函数的嵌套和链式访问
• • 5.1 函数的嵌套调用
  • 5.2 函数的链式访问
• 6. 函数的声明和定义
• • 6.1 函数声明：
  • 6.2 函数定义：
  • • 6.2.1 函数实现在多个文件
• 7. 函数递归
• • 7.1 什么是递归？
  • 7.2 递归的两个必要条件
  • • 7.2.1 限制条件
    • 7.2.2 不断接近
    • 7.2.3例子
    • • 7.2.3.1 按顺序打印整数每一位
      • 7.2.3.2 求字符串长度
  • 7.3 递归小练习
  • • 7.3.1 练习一
    • 7.3.2 练习二
    • 7.3.3 练习三
• 8.拓展训练
• • 8.1汉诺塔问题
  • 8.2 青蛙跳台阶问题

前言

函数是非常重要的，一般当我们在学的越来越多之后，我们在处理代码时就会常常使用到函数来简化主函数的冗余性，甚至学习到后期，我们不使用函数，甚至都不会写代码了

使用函数好处：详细可点击跳往原网站

1、降低复杂性

2、避免重复代码段

3、限制改动带来的影响

4、隐含顺序

5、改进性能

6、进行集中控制

7、隐含数据结构

8、隐含指针 *** 作

9、隐含全局变量

1. 函数是什么

数学中我们常见到函数的概念，但是C语言中的函数呢？

维基百科中对函数的定义：子程序

• 在计算机科学中，子程序是一个大型程序中的某部分代码， 由一个或多个语句块组
  成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。
  • 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

2. C语言中函数的分类：

1. 库函数
2. 自定义函数

2.1 库函数：

为什么会有库函数？

1. 在编程的过程中我们会频繁地将信息按照一定的格式打印到屏幕上（printf）。

2. 在编程的过程中我们会频繁地做一些字符串的拷贝工作（strcpy）。

3. 在编程时我们也经常计算，总是会计算n的k次方这样的运算（pow）。

像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

那怎么学习库函数呢？
这里我们简单的看看：www.cplusplus.com 或者 http://zh.cppreference.com（中文版）

简单的总结，C语言常用的库函数都有：

• IO函数
• 字符串 *** 作函数
• 字符 *** 作函数
• 内存 *** 作函数
• 时间/日期函数
• 数学函数
• 其他库函数

2.1.1 学习库函数

自己学习使用库函数是很重要的，学会查MSDN和cplusplus网站自学如何使用库函数目的是掌握库函数的使用方法

毕竟我们不可能记住所有库函数，所以要学会查询工具的使用

比如通过查MSDN我可以查到：

strtok

char *strtok( char *strToken, const char *strDelimit );

memmove

void *memmove( void *dest, const void *src, size_t count );

尝试使用该库函数

注：

但是库函数必须保证：使用库函数，必须包含#include其 对应的头文件。

2.2 自定义函数

假如库函数能干所有的事情，那还要程序员干什么？
所有更加重要的是自定义函数，自定义函数，简单来说就是自己写一个函数。
自定义函数和库函数一样，需要有函数名，返回值类型和函数参数。
但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间，这和画家，小说家是不是一样呢，所以说那些程序员大佬是不是都是艺术家？╰(￣ω￣ｏ)

2.2.1 函数的组成：

ret_type fun_name(para1, * )
{
	statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数

2.2.2 一些个栗子

get_min函数的设计

#include 
int get_min(int x, int y)
{
	return (x < y) ? (x) : (y);//三目操作符
}
int main()
{
	int n1 = 10;
	int n2 = 20;
	int min = get_min(n1, n2);
	printf("min = %dn", min);
	
		return 0;
}

swap函数设计
先写了一个Swap1，实现成了一个函数，但是好像不能完成任务

改成了正确的版本Swap2，就可以了

对比一下看看能不能发现问题,有时候有时候我们要思考传参是传值还是传址

#include 
void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}
void Swap2(int* px, int* py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int num1 = 1;
	int num2 = 2;
    printf("Swap1交换前:num1 = %d num2 = %dn", num1, num2);
	Swap1(num1, num2);
	printf("Swap1交换后:num1 = %d num2 = %dn", num1, num2);
	Swap2(&num1, &num2);
	printf("Swap2交换后:num1 = %d num2 = %dn", num1, num2);
	return 0;
}

函数的传值与传址（num1 num2与xy是俩个完全独立的空间，地址是不一样的）

既然没有语法问题，那一定是逻辑问题

通过这个例子，我们要引出函数实参与函数形参

3. 函数的参数 3.1 实际参数（实参）：

真实传给函数的参数，叫实参。

实参可以是：常量、变量、表达式、函数等。

无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

3.2 形式参数（形参）：

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。

形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

3.3 理解形参与实参

上面Swap1 和Swap2 函数中的参数x，y，px，py都是形式参数。在main函数中传给Swap1 的num1 ，num2 和传给Swap2 函数的&num1 ， &num2 是实际参数。
这里我们对函数的实参和形参进行分析：利用调试我们可以很容易看出过程

Swap1中 我们传了值，xy这两个形参改变了，但是走完之后仍旧没有改变num1和num2

这是因为函数调用的时候，实参传给形参，形参其实是一份实参的临时拷贝，所以在对形参修改不会影响实参

Swap中 我们传了址，由于传了地址，函数里面的px和py可以找到主函数的num1和num2，这就是指针的作用

所以可以使用px与py两个整形指针变量可以实现改变num1和num2

小结：

1. 理解一下传入函数时，Swap两者的值与地址的关系

2. 其实有时候我们设计函数要分析情况:

传值还是传地址呢？

这就引出了下一章

4. 函数的调用： 4.1 传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

4.2 传址调用

• 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
• 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接 ***
  作函数外部的变量。

对于之前的例子

碰到之前求get_min函数，抑或是求和函数，不管是较小值也好，还是求和值也好，我们只要最后的结果，自然我们不需要改变原有传过去的值，所以传值就可以解决问题。

但是假如遇到交换Swap函数，就需要传址了，因为我们需要改变传过去的两个变量地址中所存放的值不是吗，所以需要传地址来改变，才能起作用

Swap1(num1, num2);//传值
Swap2(&num1, &num2);//传址

4.3 小练习

1. 写一个函数可以判断是不是素数（100-200）。

#include
#include
//素数返回1，不是素数返回0
int is_prime(int n)
{
	//2-n-1试除法
	int j = 0;
	for (j = 2; j < sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return 0;//return 就直接结束了
		}
	}
	return 1;//之前没return就直接return 1
}
int main()
{
	int i = 0;
	for (i = 100; i <= 200; i++)
	{
		//判断i是否为素数，是就打印i
		if (is_prime(i)==1)
		{
			printf("%d ", i);
		}
	}
	return 0;
}

2. 写一个函数，实现一个整形有序数组的二分查找

#include
int Binary_Search(int arr[], int target,int sz)
{
	int left = 0;
	int right = sz-1;
	
	while (left <=right)
	{
		int mid = (left + right) / 2;
		if (arr[mid] == target)
		{
			return mid;
		}
		else if(arr[mid] target)
		{
			right = mid - 1;
		}
	}
	if (left >= right)
	{
		return -1;
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int target = 0;
	printf("输入一个下标n");
	scanf("%d", &target);
	int sz = sizeof(arr) / sizeof(arr[0]);
	int result=Binary_Search(arr,target,sz);
	if (-1==result)
	{
		printf("找不到该数n");
	}
	else
	{
		printf("找到了，下标是%dn",result);
	}
}

注意：int sz = sizeof(arr) / sizeof(arr[0]);这句话放的位置很重要

注意最好算sz的时候要在函数外面算，不然的话容易传arr[]整个数组不小心传成首地址，假如在函数内部运算时sizeof(arr)会变成4/8个字节，导致sz大小出错

3. 写一个函数判断一年是不是闰年

  int is_leap_year(int i)
  {
  	if ((i % 4 == 0) && (i % 100 != 0) || (i % 400 == 0))
  	{
  		return 1;
  	}
  	else
  	{
  		return 0;
  	}
  }
  int main()
  {
  	int y = 0;
  	for (y = 1000; y <= 2000; y++)
  	{
  		if ((is_leap_year(y)) == 1)
  		{
  			printf("%d ",y);
  		}
  	}
  	return 0;
  }

4.理解传值与传地址的区别，add函数

void add(int *p)
{
	*p+=1;
}
int main()
{
	int num = 0;
	add(&num);
	printf("%dn", num);
	return 0;
}

法二：函数返回一个int参数

int add(int n)
{
	return n+1;
}

int main()
{
	int num = 0;
	num = add(num);
	printf("%dn", num);
	return 0;
}

5. 函数的嵌套和链式访问

根据实际需求，函数和函数之间可以根据实际的需求进行组合，在这也让我们能够实现多种多样的功能，也就是可以互相调用的。

5.1 函数的嵌套调用

嵌套调用的实例

void golden()
{
	printf("重要的事情说三遍n");
}
void state()
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		golden();
	}
}
int main()
{
	state();
	return 0;
}

注：

函数可以嵌套调用，但是不可以嵌套定义

5.2 函数的链式访问

链式访问的例子：

int main()
{
	int len = strlen("Valar Moghulis");
	printf("%dn", len);
	printf("%dn",strlen("Valar Moghulis"));//嵌套调用
	return 0;
}

链式访问：函数的返回值作为另一个函数的参数

再看看下面这段代码

int main()
{
	pritnf("%d", printf("%d", printf("43")));
}

这里我们可以查阅MSDN

理解一下：

由于最里层的printf第一次会打出43，返回值是printf打出的char的个数，所以剩下两个会依次返回2和1，这里就用到了链式访问

6. 函数的声明和定义 6.1 函数声明：

什么是函数声明 ？函数声明的注意点是什么？

• 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数
  声明决定不了。

• 函数的声明一般出现在函数的使用之前。要满足先声明后使用。

• 函数的声明一般要放在头文件中的。

6.2 函数定义：

函数定义才能决定函数是否真实存在有效

函数的定义是指函数的具体实现，交待函数的功能实现。

6.2.1 函数实现在多个文件

一般我们在写一个项目或工程的时候，我们会习惯性有创建三个文件，而不是会写在一个文件里面

比如说

文件名功能作用ababa.c创建实现每个函数ababa.h声明用头文件，实现每个函数的声明，用来引用test.c测试运行文件，主函数在这里

比如在ababa.h里面，这么写：

//函数的声明
int Ababa(int x, int y);

比如说我在ababa.c里面，这么写：

#include "ababa.h"
//函数Add的实现
int ababa(int x, int y)
{
	printf("阿巴阿巴%dn",x+y);
}

又比如说我要写一个机算器：

我可以这样创造文件和其功能的实现，分别在不同源文件里面实现不同的计算器功能，最后整合成计算器

7. 函数递归 7.1 什么是递归？

程序调用自身的编程技巧称为套娃。

递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法

它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于：把大事化小

注：但有时候会增加程序的运算时间

7.2 递归的两个必要条件 7.2.1 限制条件

凡是递归必须要由一个限制条件:

而存在着限制条件，当满足这个限制条件的时候，递归便不再继续。

7.2.2 不断接近

凡是递归必须要满足:

每次递归调用之后结果越来越接近这个限制条件，自然不能越来越远离

比如说 编写函数求字符串的长度,不允许创建临时变量

7.2.3例子 7.2.3.1 按顺序打印整数每一位

接受一个无符号整型值，按照顺序打印它的每一位。

#include 
void print(int n)
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}
int main()
{
	int num = 1234;
	print(num);
	return 0;
}

7.2.3.2 求字符串长度

编写函数求字符串的长度，不允许创建临时变量

#include 
int my_strlen1(char* s)
{
	int count = 0;//临时变量,不行
	while (*s != '')
	{
		count++;
		s++;
	}
	return count;
}
int my_strlen(const char* str)//利用递归
{
	if (*str == '')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	char* p = "Icandoallthings";
	int len = my_strlen(p);
	printf("%dn", len);
	return 0;
}

7.3 递归小练习 7.3.1 练习一

//求n的阶乘。（不考虑结果会溢出）
int factorial(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * factorial(n - 1);
}

但是我们发现有问题:使用factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

7.3.2 练习二

过程就是

Print(1234)
Print(123) 4
Print(12) 3 4
Print(1) 2 3 4

//接受一个整型值（无符号），按照顺序打印它的每一位。
//例如：输入：1234，输出 1 2 3 4.
#include 
void Print(int n)
{
	if (n > 9)
	{
		Print(n / 10);
	}
	printf("%d ", n % 10);
}
int main()
{
	int num = 1234;
	Print(num);
	return 0;
}

7.3.3 练习三

一个很经典的例子：求第n个斐波那契数。（不考虑结果溢出）

int Fibonachi(int n)
{
if (n <= 2)
	return 1;
else
	return Fibonachi(n - 1) + Fibonachi(n - 2);
}

但是我们发现有问题:在使用Fibonachi这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
为什么呢？

• 我们发现fib 函数在调用的过程中很多计算其实在一直重复,越多越慢

如果我们把代码修改一下：

int count = 0;//全局变量
int Fibonachi(int n)
{
	if(n == 3)
		count++;
	if (n <= 2)
		return 1;
	else
		return Fibonachi(n - 1) + Fibonachi(n - 2);
}

我们可以输出看看count，来看循环次数，他是一个很大很大的值。

那我们如何改进呢？
在调试factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）

为什么会报错栈溢出？

已知每一次调用函数都要在栈区开辟一部分内存空间，而系统分配给程序的栈空间是有限的，但是如果出现了死循环，这样有可能导致一直开在辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。

注：

那么是否每当我们发现报错是栈溢出，是否我们可以思考一下是否可能是循环出了问题

那如何解决上述的问题：

1. 将递归改写成非递归。
2. 使用static对象替代nonstatic 局部对象。在递归函数设计中，可以使用static 对象替代
   nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic 对象的开销，而且static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

8.拓展训练 8.1汉诺塔问题

思路分析请阅读RAIN 7博客

void hanoi(int n, char x, char y, char z)
{
	if (n == 1)//递归终止于此
		move(x, z);
	else
	{
		hanoi(n - 1, x, z, y);   //将n-1个盘子从x柱借助z柱移动到y柱上去
		move(x, z);				 // 将x柱上剩下的一个盘移动到z柱上
		hanoi(n - 1, y, x, z);   //将n-1个盘从y柱借助x柱移动到z柱上
	}
}
int main()
{
	int n = 0;
	printf("请输入初始的圆盘数：");
	scanf("%d", &n);
	hanoi(n, 'A', 'B', 'C');
	return 0;
}

8.2 青蛙跳台阶问题

思路分析请阅读RAIN 7博客

//青蛙跳台阶问题
#include 
 int Fun(int n)
{
	if (n == 1)
		return 1;
	else if (n == 2)
		return 2;
	else if (n>2)
		return  Fun(n - 1) + Fun(n - 2);
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret=Fun(n);
	printf("%dn", ret);
	return 0;
}

小结：

函数与递归就到这里了，递归还是有一些难度的，函数说到底还是很重要的，大家阅读完如果觉得还可以，希望留下赞和关注哦