函数和递归

#两个库函数
1.
strcpy

char * strcpy ( char * destination, const char * source );

memset：Sets buffers to a specified character(将缓冲区设置为指定字符)

void * memset ( void * ptr, int value, size_t num );

注： 但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。
void 为无数据类型 不能直接定义一个数字

	void a = 10;//错误
	void* p = "hello";//正确

自定义函数
自定义函数和库函数一样，有函数名，返回值类型和函数参数。 但是不一样的是这些都是我们自己来设计。
写一个函数可以找出两个整数中的最大值

int Max(int a, int b)
{
	return a > b ? a : b;
}
int main
{
	int ret = Max(10, 20);
	printf("%d\n", ret);
}

### 函数的参数
实际参数（实参）：
真实传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
形式参数（形参）：
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
形参交换无法改变实参的值，应该用地址

void Swap(int *pa,int *pb)
{
	int tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
int main()
{
    int a = 10;
    int b = 20;
    printf("交换前：%d,%d\n",a,b);
    *int tmp = a;
    a = b;
    b = tmp;*/
    Swap(&a,&b);//按址传递
    printf("交换后：%d,%d\n", a, b);
}

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

int Max(int a, int b)
{
	return a > b ? a : b;
}
int Max3(int a,int b,int c)
{
	int max = Max(a,b);
	int max2 = Max(max,c);
	return max2;
}

2.链式访问

int Max(int a, int b)
{
	return a > b ? a : b;
}
int Max3(int a,int b,int c)
{
	return Max(Max(a, b),c);//链式调用
}

##### 函数的声明和定义
函数声明：

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，无关紧要。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的。
   函数定义：
   函数的定义是指函数的具体实现，交待函数的功能实现。
   1.test.h的内容 放置函数的声明
   #ifndef TEST_H
   #define TEST_H
   //函数的声明
   int Add(int x, int y);
   #endif //TEST_H
   2.test.c的内容 放置函数的实现
   #include “test.h”
   //函数Add的实现
   int Add(int x, int y)
   {
   return x+y;
   }
   “” : 优先去库当中去找,去本地的头文件下去找
   <>:只会去库中去找
   只要是#include 就会将包含的这个头文件 的全部内容
   拷贝到当前的.c文件当中
   #ifndef TEST_H
   #define TEST_H

#endif //__TEST_H__或
#pragma once
作用：预防头文件重复引用
###### 函数递归
什么是递归？
程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于：把大事化小
递归的两个必要条件
存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。
例如求5！

int Fac2(int n)
{
	if (n == 1) 
	{
		return 1;
	}
	int tmp = n * Fac2(n - 1);
	return tmp;
}

画图理解

函数的执行发生在栈上
遵循 先进后出原则