1、函数是什么

学习库函数网站：

• https://cplusplus.com/reference/
• http://en.cppreference.com
• http://zh.cppreference.com

我们参考文档，学习几个库函数

2、库函数

3、自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数

函数的组成：

ret_type fun_name(para1,*)
{
    statement;   //语句项          //函数体
}

ret_type    //返回值类型
fun_name    //函数名
para1       //函数参数

4、函数参数

4.1、创建函数实现两个整形变量交换值

通过下面有问题的代码，讲解实参和形参：

#define _CRT_SECURE_NO_WARNINGS
#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", a, b);
    return 0;
}

输出：

我们会发现，变量a、b的值并没有交换！！！

那问题出现在哪里呢？

经过调试后发现Swap()函数里面的x，y值没有转给a，b，所以a，b一直都是10，20。

原因总结：变量a,b叫做实参。变量x,y叫做形参。当实参传递给形参的时候，形参是实参的临时拷贝。对形参的修改不会影响到实参。

那知道了问题后，怎么解决呢？

利用我们前面学到的指针变量的方法：

int main()
{
    int a = 0;
    int* p = &a;
    a = 20;      //直接修改a的值
    *p = 30;     //间接修改a的值
    return 0;
}

也就是说我们可以利用a，b的地址，然后赋值进行修改，从而达到交换值得目的

代码实现：（好好体会）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void Swap(int* px,int* py)
{
    int z = *px;    //z = a
    *px = *py;      //a = b
    *py = z;        //b = a
}

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", a, b);
    return 0;
}

那下面我们再来实现一下两个函数的加法：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

Add(int x,int y)
{
    int z = 0;
    z = x + y;
    return z;
}

int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    int c = Add(a, b);
    printf("%d\n", c);
    return 0;
}

提问：为什么实现两个变量值的交换需要传指针参数，而实现两个值相加不需要传指针参数呢？

那我们什么时候需要传指针参数，什么时候不需要呢？

• 当我们需要改变变量a，b的值时就需要使用指针变量
• 否则不需要

4.2、实际参数（实参）

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

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

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

4.3、形式参数（形参）

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

并且形参实例化后相当于实参的临时拷贝。

实参和形参的参数名可以相同也可以不相同。

5、函数调用

5.1、传值调用

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

5.2、传址调用

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

Swap1(a,b)                //传值调用

Swap(&a,&b)               //传址调用

6、函数的嵌套调用和链式访问

函数和函数之间可以根据实际的需求进行组合，也就是互相调用。

6.1、链式访问

把一个函数的返回值作为另一个函数的参数。特别注意：是一个函数的返回值作为另一个函数的参数

所以链式访问的前提是函数必须要有返回值。

那我们来看下面的代码：

#include <stdio.h>
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    return 0;
}

输出：

分析：首先我们要知道printf()函数的打印和返回值不是一回事，printf()函数的返回值是返回数据的个数，比如这里：打印的是43，43是两个数字，所以printf()函数的返回值是2。那好，我们从左向右依次分析，首先最里面的printf()函数打印出43，并且返回2传给中间的那个printf()函数，那后中间的那个函数打印2，因为2是一个数字，所以中间的printf()返回值1并传给最左侧的printf()函数，然后左侧的printf()函数打印1。因此输出结果为4321。

7、函数的声明和定义

7.1、函数的声明

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

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

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

我们在写两个数相加时，Add()函数就写在main()函数上面，但是如果我们将Add()函数写在main()函数下面，程序也可以运行，就是会警告，如果想取消警告我们就需要声明：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

//函数声明
int Add(int, int);            //两种写法都可以
int Add(int x, int y);


int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    int ret = Add(a, b);
    printf("%d", ret);
    return 0;
}


//函数的定义
int Add(int x,int y)
{
    return x + y;
}

但是在实际业务中，我们不会这样写，我们会怎么办呢？我们可以创建个add.c源文件和add.h头文件。然后把Add()函数部分放进add.c源文件中，把函数声明--->int Add(int, int); 放进add.h头文件中，最后在main函数所在的.c源文件中，引入add.h头文件即可。(这里add.c和add.h文件不在演示创建，只演示引入头文件)：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "add.h";                 //引入add.h头文件

int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    int ret = Add(a, b);
    printf("%d", ret);
    return 0;
}

7.2、函数的定义

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

8、函数递归和迭代

迭代就是非递归

8.1、什么是递归？

程序调用自身的编程技巧称为递归（recursion）。

递归作为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

递归策略只需要少量的程序就可以描述出问题过程所需要的多次重复计算，大大的减少了程序的代码量。

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

8.2、递归的两个必要条件

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

8.3、做几个例题

8.3.1、接收一个整型值（无符号），按照顺序打印它的每一位。

例如：

输入：1234，输出：1 2 3 4。

分析：要想分别拿到1 2 3 4我们可以这样做：将1234 % 10 ，会得到4，然后将1234 / 10会得到123，然后将123 % 10会得到3，然后将123 / 10会得到12，将12 % 10会得到2，将1 % 10会得到1，然后1 / 10会得到0。

#define _CRT_SECURE_NO_WARNINGS
#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("%d", &num);
    print(num);
    return 0;
}

我们想一下如果不加if语句，那就会死递归的调用print()函数，最终会导致栈溢出（stack overflow）。

因为每一次函数的调用都会在栈区申请空间，反复调用就会一直申请空间，最终导致栈溢出。

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

版本一： 我们先来写个允许创建临时变量的代码：

#include <stdio.h>

my_strlen(char* str)
{ 
    int count = 0;            //这个就是创建的临时变量
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    char arr[] = "1234";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}

版本二：但是现在要求不能创建临时变量，所以需要使用递归的方法来实现。

#include <stdio.h>

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

int main()
{
    char arr[] = "1234";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}

版本三：写出好代码之后的改良：

#include <stdio.h>
#include <assert.h>
my_strlen(const char* str)       //我们求字符串长度的，不需要修改字符串，所以加上const可以有效防止字符串被修改。
{
    int count = 0;           
    assert(str);         //这个是防止str传来的是空指针，如果str传的是空值，空值为0，0为假，那assert就会报错。
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    char arr[] = "1234";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}

8.3.3、使用递归实现n!

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int fac(int x)
{
    if (x <= 1)
    {
        return 1;
    }
    else
    {
        return x * fac(x - 1);
    }

}

int main()
{
    int n = 0;
    scanf("%d", &n);
    int ret = fac(n);
    printf("%d\n", ret);
    return 0;
}

8.3.4、求第n个斐波那契数

斐波那契数：1 1 2 3 5 8 13 21 34 55...

#define _CRT_SECURE_NO_WARNINGS
#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", ret);
    return 0;
}

但是这个用递归就不太适合，当n=50时，会计算很长时间。那就用迭代的方法：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int Fib(int n)
{
    int a = 1;
    int b = 1;
    int c = 0;
    int i = 0;
    if (n <= 2)
    {
        return 1;
    }
    else
    {
        for (i=1; i <= n - 2;i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }


}

int main()
{
    int n = 0;
    scanf("%d", &n);
    int ret = Fib(n);
    printf("%d", ret);
    return 0;
}

8.4、递归的几个经典问题（斐波那契数列）

• 汉诺塔问题
• 青蛙跳台阶问题

8.5、小乐乐跳台阶问题

小乐乐上课需要走n阶台阶，因为他腿比较长，所以每次可以选择走一阶或者走两阶，那么他一共有几种走法？

输入描述：输入包含一个正数n（1<=n<=30）

输出一个整数，即小乐乐可以走的方法数。

问题分析：

• 当n=1时，只有一种走法。
• 当n=2时，有两种方法。
• 当n>2时，Fib(9) + Fib(8)种方法发

分析为什么n=2有Fib(9) + Fib(8)种方法：

假设函数Fib(n)是计算走n个台阶的走法。

假设n=10：

• 如果小乐乐走1阶，还剩9阶，那么就有Fib(9)种走法。
• 如果小乐乐走2阶，还剩8阶，那么就有Fib(8)种走法。

所以当n=10时，可以有 Fib(9) + Fib(8)种方法。

那么同理Fib(n)就有 Fib(n-1)+Fib(n-2)种方法。

这样就转为斐波那契数列的问题了。

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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

int main()
{
    int n = 0;
    scanf("%d", &n);
    int ret = Fib(n);
    printf("%d", ret);
    return 0;
}

输出：