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

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

下面我们来写一个函数用来交换两个整型变量的内容?：

#include <stdio.h>
void swap(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//交换两个变量
	printf("交换前a=%d b=%d\n", a, b);
	swap(a, b);
	printf("交换后a=%d b=%d\n", a, b);

	return 0;
}

我们可以看到函数swap并不能实现a和b的值的互换。下面我们来调试一下看看空间内存的分配情况。

🍎：当函数调用的时候，实参传给形参，形参其实是实参的一份临时拷贝。所以对形参的修改，不会影响实参。

?修改后代码：

#include <stdio.h>
void swap(int*pa, int*pb)
{
	int z = 0;
	z = *pa;
	*pa = *pb;
	*pb = z;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//交换两个变量
	printf("交换前a=%d b=%d\n", a, b);
	swap(&a, &b);
	printf("交换后a=%d b=%d\n", a, b);

	return 0;
}

?修改后运行结果：

4.函数传参：

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

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

下面我们写一个函数，实现一个整型有序数组的二分查找，找到了就返回下标，找不到返回-1.?

#include <stdio.h>
//int binary_search(int * arr, int k, int 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 = 7;
	//数组arr传给binary_search函数的时候，其实传递的是arr数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);

	int ret = binary_search(arr, k, sz);
	if (-1 == ret)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了，下标是%d\n", ret);
	}
	return 0;
}

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

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

嵌套调用：

#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;
}

嵌套定义：?

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

#include <stdio.h>
#include <string.h>

int main()
{
	int ret = strlen("abc");
	printf("%d", ret);
	return 0;
}

我们可以直接将strlen函数的返回值作为printf函数的参数。

#include <stdio.h>
#include <string.h>

int main()
{ 
	printf("%d", strlen("abc"));
	return 0;
}

?6.函数的声明与定义

函数的声明：

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

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

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

函数的定义：

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

对于一个大的工程，函数声明主要放在头文件中，函数实现放在另一个源文件中，主文件调用函数实现功能。?

7.函数递归

函数递归：程序调用自身的编程技巧称为递归—函数调用自己就是递归。

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

递归的两个条件：

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

每次递归调用之后越来越接近这个限制条件。

? ? ? ? ? ?🍎：Stack overflow —栈溢出，递归代码中最常见的错误。

下面我们写一个题目感受一下递归：输入一个无符号整型值，按照顺序打印它的每一位。

思路分析：比如我们输入1234，那么我们就需要打印出来：1 2 3 4 。我们知道对于一个数字它的个位数是最容易得到的，我们只需要%10就可以得到一个数字的个位数字。那我们不如创建一个函数，函数将1234数字分为123和4，我们再把123分为12和3，把12又分为1和2，最终打印出来。

代码实现：

#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;
}

?栈溢出问题：

?：每一次函数调用都会在内存的栈区申请一块空间。当函数调用次数太多会导致栈区空间不? ? ? ? ? ? ? 足，导致栈溢出。

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

创建临时变量的常规方法：?

#include <stdio.h>
int my_strlen(char* s)
//arr数组里面的数据为字符类型，s代表的是arr数组里面的第一个元素的地址。
{
	int count = 0;
	while (*s != '\0')
	{
		count++;
		s++;
	//s代表的是字符a的地址，因为数组中元素的地址是连续的，同时char数据类型占据
	//一个字节，所以s++就是下一个元素的地址，如果数组中元素数据类型为int，则s+=4.
	}
	return count;
}

int main()
{
	//求字符串的长度
	char arr[] = "abc";
	//arr是数组名，数组名是数组首元素的地址

	int len = my_strlen(arr);//创建求字符串长度的函数my_strlen
	printf("%d\n", len);
	return 0;
}

?下面我们不用临时变量，用递归的方法：

#include <stdio.h>
int my_strlen(char* s)
//arr数组里面的数据为字符类型，s代表的是arr数组里面的第一个元素的地址。
{
	if (*s == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen(s + 1);
	}
}

int main()
{
	//求字符串的长度
	char arr[] = "abc";
	//arr是数组名，数组名是数组首元素的地址

	int len = my_strlen(arr);//创建求字符串长度的函数my_strlen
	printf("%d\n", len);
	return 0;
}

?8.递归和迭代

1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。

2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。

3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。

循环就是一种迭代方式，迭代里面包括循环。

例题1：下面我们在不考虑栈溢出的情况下求n的阶乘：

循环：

#include <stdio.h>
int main()
{
	int n = 0;
	int ret = 1;
	scanf("%d", &n);
	//循环产生1~n的数字
	int i = 0;
	for (i = 1; i <= n; i++)
	{
		ret = ret * i;
	}
	printf("ret=%d\n", ret);
	return 0;
}

递归：

#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("%d\n", ret);
	return 0;
}

?例题2：求第n个斐波那契数：

利用递归相对来说运算有点大，稍微大点的数字就很不好计算：

#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("%d\n", ret);
	return 0;
}

普通方法：

#include <stdio.h>
int fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	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("%d\n", ret);
	return 0;
}