函数传值与传址举例：

传值打印：
#include<stdio.h>

void add(int n)
{
	n++;
}

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;

}
传址打印：
void add(int* 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;
}
返回值打印：
int add(int n)
{
	n++;
	return n;
}

int main()
{
	int num = 0;
	num = add(num);
	printf("%d\n", num);

	num = add(num);
	printf("%d\n", num);

	num = add(num);
	printf("%d\n", num);

	return 0;
}
函数不能嵌套定义！但是可以嵌套调用！

函数的链式访问：

将strlen的返回值作为printf的第二个参数：

1.函数定义再主函数后要再主函数前声明，

2.函数定义在主函数前可不声明

或者将声明放在自定义头文件

放在头文件里可封装保护内部代码
#include "add.h"

//导入静态库
#pragma comment(lib, "add.lib")

int main()
{
	int a = 10;
	int b = 20;
	int ret = Add(a, b);
	printf("%d\n", ret);

	return 0;
}
test.h的内容放置函数的声明
#ifndef __TEST_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;
}
什么是递归？

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

递归的两个必要条件：

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

2.每次递归调用之后越来越接近这个限制条件。
 // 是递归的代码，但是会死递归
int main()
{
	printf("hehe\n");
	main();

	return 0;
}
编写函数不允许创建临时变量，求字符串的长度！
int my_strlen1(char* s)
{
	int count = 0;//临时变量
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}


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

	printf("%d\n", len);

	return 0;
}
int my_strlen(char* s)
{
	if (*s == '\0')
		return 0;
	else
		return 1 + my_strlen(s + 1);
}

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

	printf("%d\n", len);

	return 0;
}
题目——求n的阶乘
//求n的阶乘
//1 2 3 .. n


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;
}
求第n个斐波那契数。（不考虑溢出）
int fib(int n)
{
 if (n <= 2)        
 return 1;
    else
    return fib(n - 1) + fib(n - 2);
}
但是我们发现有问题；

在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

优化1

为什么呢？我们发现 fib 函数在调用的过程中很多计算其实在一直重复。如果我们把代码修改一下：

最后我们输出看看count，是一个很大很大的值。那我们如何改进呢？在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）这样的信息。

系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出
int count = 0;
int fib(int n)
{
	if (n == 3)
		count++;

	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);

	printf("\ncount = %d\n", count);

	return 0;
}
那如何解决上述的问题：

1. 将递归改写成非递归。

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

提示：

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

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

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

优化2
int count = 0;
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);

	printf("\ncount = %d\n", count);

	return 0;
}