c语言分层理解（c语言函数）

文章目录

• 1. 函数是什么？
• 2. c语言中函数的分类
• • 2.1 库函数
  • • 2.1.1 为什么要有库函数？
    • 2.1.2 怎么去了解和学习呢?
    • • 2.1.2.1 strcpy函数介绍
      • 2.1.2.2 memset函数介绍
  • 2.2 自定义函数
• 3.函数的参数
• • 3.1 实际参数
  • 3.2 形式参数
• 4. 函数的调用
• • 4.1 传值调用
  • 4.2 传址调用
  • 4.3 小练
  • • 4.3.1 写一个函数，实现一个整形有序数组的二分查找
    • 4.3.2 写一个函数，每调用一次这个函数，就会将num的值增加1
• 5.函数的嵌套调用和链式访问
• • 5.1 嵌套调用
  • 5.2 链式访问
• 6.函数的声明和定义
• • 6.1 函数声明
  • 6.2 函数定义
• 7.函数递归
• • 7.1递归是什么？
  • 7.2 递归的两个必要条件
  • • 7.2.1 练习一 接受一个整型值（无符号）按顺序打印它的每一位
    • 7.2.2 练习二 编写函数不允许创建临时变量，求字符串的长度
  • 7.3 递归和迭代
  • • 7.3.1 练习一 求n的阶乘
    • 7.3.2 练习二 求第n个斐波那契数

1. 函数是什么？

数学中函数是一种映射关系，c语言中函数是子程序，一般会有输入参数并有返回值，提供对过程的包装和细节的隐藏。

2. c语言中函数的分类

c语言中有库函数和自定义函数两种。

2.1 库函数 2.1.1 为什么要有库函数？

先来了解一下库函数是什么？把函数放到库里，供别人使用的一种方式。
为社么要有？因为在我们日常生活中要解决的事情如果要引入的函数出现的次数很多，比较繁琐、麻烦的时候我们引入库函数这个概念，在库函数里面我们规定了这些事情的做法，只需要拿出来使用即可，并不用管太多，而且你拿出来直接使用，这样提高了效率，减少了时间成本。

2.1.2 怎么去了解和学习呢?

我这里有一个关于c/c++的网站很好用，分享一下cplusplus，这个网站很好用。请允许我用两个函数来介绍一下。

2.1.2.1 strcpy函数介绍

run代码：

再看一个例子：

在打开后，搜索该函数，函数介绍模板分为：基本理解（funcation）、参数（parameters）、返回值（return vaule）、例子（example）、其他（see also）。这几个模板充分介绍了该函数，大佬们应该都懂，英文肯定比我好。

2.1.2.2 memset函数介绍

run代码：

2.2 自定义函数

自定义函数和库函数一样，有函数名、返回值类型、函数参数。自定义函数就是用来解决库函数中没有的一些解决事情的办法。

具体格式：

ret_type fun_name(para1)
{
    statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1   函数参数，参数可能不止一个

3.函数的参数 3.1 实际参数

真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形
参。

3.2 形式参数

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内
存单
元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有
效

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

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

通过代码来了解：

4.2 传址调用

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

代码实现（完成两个数交换）：

4.3 小练 4.3.1 写一个函数，实现一个整形有序数组的二分查找

#include 
int binary_search(int arr[], int n ,int sz)
{
	//二分查找要有左右下标
	int leftsub = 0;
	int rightsub = sz - 1;

	while (leftsub <= rightsub)
	{
		int	midsub = leftsub + (rightsub - leftsub) / 2;
		if (arr[midsub] > n)
		{
			rightsub = midsub - 1;
		}
		else if (arr[midsub] < n)
		{
			leftsub = midsub + 1;
		}
		//找到了直接返回下标
		else
		{
			return midsub;
		}
	}
	//因为数组中下标包括0、1、2....所以用-1
	return -1;
}
int main()
{
	//创建一个有序数组
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int n = 0;
	scanf("%d", &n);//要查找的数
	//实现二分查找函数
	int ret = binary_search(arr,n,sz);//返回下标
	//如果找到则打印下标
	if (ret == -1)
	{
		printf("没找到n");
	}
	else
	{
		printf("找到了，下标是：%dn",ret);
	}
	return 0;
}

这里有个问题，就是为什么我们要传进一个数组的大小，而不是在函数中计算，就是这样的：

#include 
int binary_search(int arr[], int n)//传的是数组名（数组名相当于一个指针）
{
	//二分查找要有左右下标
	int LeftSub = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//所以这里的arr是一个指针，这里的sz=1(在32位下）
	int RightSub = sz - 1;

	while (LeftSub <= RightSub)
	{
		int	MidSub = LeftSub + (RightSub - LeftSub) / 2;
		if (arr[MidSub] > n)
		{
			RightSub = MidSub - 1;
		}
		else if (arr[MidSub] < n)
		{
			LeftSub = MidSub + 1;
		}
		//找到了直接返回下标
		else
		{
			return MidSub;
		}
	}
	//因为数组中下标包括0、1、2....所以用-1
	return -1;
}
int main()
{
	//创建一个有序数组
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	
	int n = 0;
	scanf("%d", &n);//要查找的数
	//实现二分查找函数
	int ret = binary_search(arr, n);//返回下标
	//如果找到则打印下标
	if (ret == -1)
	{
		printf("没找到n");
	}
	else
	{
		printf("找到了，下标是：%dn", ret);
	}
	return 0;
}

这里我们运行起来：

问题出现了，在这个数组中不是有4吗？最后却找不到呢？离谱，下面我来告诉你原因，调试起来（在32位下）：

我们发现了问题，sz=1，说明了形参中arr数组名是个首元素地址，sizeof中的arr是个指针，所以计算的时候，在32位设备下，指针大小是4个字节，所以sz=1。
在正常情况下，数组大小的计算已经在函数创建之前就计算好了的情况下，再来看看：

这里的sizeof里面的arr是整个数组的大小，并非首元素地址。
结论：数组传参一定要传数组的大小，数组名就是指针。

4.3.2 写一个函数，每调用一次这个函数，就会将num的值增加1

#include 
传址调用
//void func(int *n)
//{
//	*n = *n + 1;
//}
//int main()
//{
//	int num = 0;
//	func(&num);
//	printf("%dn", num);
//	func(&num);
//	printf("%dn", num);
//	func(&num);
//	printf("%dn", num);
//	return 0;
//}
//传值调用
int func(int n)
{
	return (n + 1);
}
int main()
{
	int num = 0;
	int add = func(num);
	printf("%dn", add);
	int add1= func(add);
	printf("%dn", add1);
	int add2 = func(add1);
	printf("%dn", add2);
	return 0;
}

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

void new_line()
{
	printf("hehen");
}
void three_line()
{
	int i = 0;

	for (i = 0; i < 3; i++)
	{
		new_line();
	}
}
int main()
{
	three_line();
	return 0;
}//这就是嵌套，three_line函数嵌套new_line函数。

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

这里的错误明显是想要我们把fun2()函数改为调用形式。

5.2 链式访问

这里我们要知道printf函数的返回值是一个整型值，返回所写的字符的个数。
所以这里先打印43，再打印2， 在再打印1。

再举一例：

#include 
int main()
{
	printf("%dn", strlen("abcdef"));
	return 0;
}//printf函数嵌套使用strlen函数，输出结果是6

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

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了.（简单的说就是告诉编译器有这么个函数，声明中的形参在函数被调用时并不开辟空间）
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。

6.2 函数定义

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

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

递是推递的意思，归是回归的意思。
程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式就是把大事化小。

7.2 递归的两个必要条件

1.存在限制条件，当满足这个限制条件时，递归便不再继续
2.每次递归调用之后越来越接近这个限制条件。

7.2.1 练习一 接受一个整型值（无符号）按顺序打印它的每一位

思路：

run代码：

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

	print(n);
	return 0;
}

具体理解：

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

思路：

首先编写一个程序求字符串长度，再编写一个不创建临时变量的函数求字符串长度。求字符串首先想到用strlen库函数求；我们在想想可不可以用循环，当遇到不是’’的字符就用计数器加一，碰到’’时就结束循环；再想想，我们可以用递归的方法，每遇到一个不为’’的字符就加一，然后用指针指针指向下一个字符进行判断。思路循序渐进，一步一步推导让这个题目变得有头绪。

//假设这个字符串是"abc"
//第一种方法用strlen库函数求解
#include 
#include 
int main()
{
	char arr[] = "abc";
	int num = strlen(arr);
	printf("%dn", num);
	return 0;
}

//假设这个字符串是"abc"
//我们在想想可不可以用循环，当遇到不是''的字符就用计数器加一，碰到''时就结束循环
#include 
int my_strlen(char *str)
{
	//设置计数器
	int count = 0;
	//然后实现函数功能
	while (*str != '')
	{
		count++; 
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abc";
	//求完长度后返回长度值
	int len = my_strlen(arr);
	printf("%dn", len);
	return 0;
}

//利用递归的方法实现不创建临时变量求解字符串长度
#include 
int my_strlen(char* str)
{
	while (*str != '')
	{
		return 1 + my_strlen(str + 1);
	}
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%dn", len);
	return 0;
}

7.3 递归和迭代 7.3.1 练习一 求n的阶乘

思路：

当n<=1时，return 1;当n>1时，return nfactorial(n-1)

//递归
#include 
int factorial(int x)
{
	if (x <= 1)
		return 1;
	else
		return x * factorial(x - 1);
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int mul = factorial(n);
	printf("%dn", mul);
	return 0;
}

这里有一个问题，就是当我们计算一个很大的数字的阶乘的时候，会产生很大的数，当这个数字超出存储的int类型（四个字节）的大小的时候，数据会丢失，也就出现栈溢出（stack overflow）的现象。
如何解决这个问题？
将递归改写为非递归

//迭代
#include 
int factorial(int n)
{
	int ret = 1;
	while (n>1)
	{
		ret *= n;
		n -= 1;
	}
	return ret;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int mul = factorial(n);
	printf("%dn", mul);
	return 0;
}

7.3.2 练习二 求第n个斐波那契数

思路：

当n<=2时，return 1;当n>2时，return fib(n-1)+fib(n-2)

//递归
//求第n个斐波那契数
//1 1 2 3 5 8 13 21 34 55...
#include 
fib(int x)
{
	if (x <= 2)
		return 1;
	else
		return fib(x - 1) + fib(x - 2);
}
int main()
{
	int n = 0;
	//输出第几个数字
	scanf("%d", &n);
	int fib_number=fib(n);
	//数组这个斐波那契数
	printf("%dn", fib_number);
	return 0;
}

这段代码有个问题，就是在我们计算第50个斐波那契数的时候特别浪费时间。
为什么浪费时间呢？看图：

有很多重复调用，我们来看看3这个数字被调用了多少次？

怎么解决这个问题呢？
将递归改写为非递归

//迭代
#include 
int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	//a  b  c
	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("%dn", ret);
	return 0;
}

提示：

1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运时开销。
4. 递归一定要有限制条件，不然就是死递归。
5. 循环只是迭代的一种，可不能认为迭代就是循环。
6. 递归会出现重复或者栈溢出问题，这时我们就要用迭代或者非递归形式去解决具体问题。