第三章-函数

一、函数

1. 函数是什么

（1）概念

函数是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

#include<stdio.h>
int Add(int x, int y)
{
    int z = 0;
    z = x + y;
    return z;
}
int main()
{
    int a = 10;
    int b = 20;
    int sum = Add(a, b);
    printf("%d\n", sum);
    return 0;
}

 

2.C语言中函数的分类

（1） 库函数

C语言常用的库函数都有：

• IO函数（输入、输出函数）
• 字符串操作函数（strlen）
• 字符操作函数（大写转小写）
• 内存操作函数
• 时间/日期函数（time）
• 数学函数（sqrt）
• 其他库函数

• #define _CRT_SECURE_NO_WARNINGS
  #include<stdio.h>
  #include<string.h>
  //strcpy--字符串拷贝
  //char * strcpy
  //strlen--字符串长度有关
  int main()
  {
      char arr1[] = "bit";
      char arr2[] = "######";
      //\0是字符串的结束标志
      strcpy(arr2, arr1);
      printf("%s\n", arr2);//bit
      return 0;
  }

（2） 自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数。 自己进行设计。

例：以找出两个整数中的最大值

#include<stdio.h>
//定义函数
int get_max(int x, int y)
    {
        return (x > y) ? (x) : (y);
        //if(x>y)
        //return x;
        //else
        //return y;
    }
    int main()
    {
        int a= 10;
        int b= 20;
        int max = get_max(a,b);
        printf("max = %d\n", max);
    return 0;
}

例：交换两个整形变量的内容

#include <stdio.h>
//Swap1错误
//void Swap1(int x, int y)//x=10,y=20
//void无返回值
//x、y创建新空间
//a、b与x、y没有关系
//{
//    int tmp = 0;//临时变量,创建临时空间
//    tmp =x;//
//    x = y;
//    y = tmp;
//}
Swap2(int* pa,int* pb)
{
    int tmp = 0;
    tmp = *pa;
    *pa = *pb;
    *pb = tmp;
}
int main()
{
    int a= 10;//创建a空间
    int b = 20;//创建b空间
    printf("a = %d b = %d\n", a, b);
    //Swap1(a, b);
    Swap2(&a,&b);
    printf("a = %d b = %d\n", a, b);
    return 0;
}

int main()
{
    int a = 10;
    int* pa = &a;//pa指针变量
    *pa = 20;//解引用操作
    ptintf("%d\n", a);//20
    return 0;
}

 

3. 函数参数

（1）实际参数（实参）

真实传给函数的参数

（2）形式参数（形参）

指函数名后括号中的变量，形式上的参数。形式参数函数调用完成之后自动销毁。

形参其实是实参的临时拷贝，对形参的修改是不会改变实参

 

5. 函数调用

（1）传值调用

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

（2）传址调用

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

（3）练习

1. 打印100到200的素数

#include<stdio.h>
#include<math.h>
int is_prime(int n)
{
    //2~n-1 之间的数字
    int j = 0;
    for (j = 2; j <=sqrt(n); j++)
    {
        if (n % j == 0)//即n被整除，不是素数
            return 0;//返回0
    }
    return 1;//返回整数
}
int main()
{
  //10-200
    int i = 0;
    int count=0;
    for (i = 100; i <= 200; i++)
    {
      //判断i是否为素数
        if (is_prime(i) == 1)
        {
            count++ ；
            printf(" %d",  i );
          }
    }
    printf(" \ncount = %d\n",count);
    return 0;
}

2. 写一个函数判断一年是不是闰年。

#include<stdio.h>
int is_leap_year(int y)
{
    if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
        return 1;
    else
        return 0;
}
int main()
{
    int year = 0;
    for (year = 1000; year <= 2000; year++)
    {
        if (is_leap_year(year))
        {
            printf(" %d", year);
        }
    }
    return 0;
}

 

3. 写一个函数，实现一个整形有序数组的二分查找。

#include<stdio.h>
//传递的是arr地址
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;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int ret = binary_search(arr, k,sz);//binary_search二分查找
        if (ret == -1)
        {
            printf("找不到\n");
    }
        else
        {
            printf("找到了，下标是：%d\n", ret);
        }
        return 0;
}

 

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

#include<stdio.h>
void Add(int* p)
{
    (*p)++;
}
int main()
{
    int num = 0;
    Add(&num);
    printf("num= %d\n", num);
    Add(&num);
    printf("num= %d\n", num);
    Add(&num);
    printf("num= %d\n", num);
    return 0;
}

 

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

（1）嵌套调用

函数和函数之间可以进行组合的。

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

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

（2）链式访问

把一个函数的返回值作为另外一个函数的参数

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
    int len = 0;
    //int len = strlen("abc");//strlen函数
    //printf("%d\n",len);
    printf("%d\n",strlen("abc"));//链式访问
    return 0;
}

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

 

7. 函数的声明和定义

（1）函数声明

出现在函数的使用之前，放在头文件中的

#include <stdio.h>
//函数声明
int Add(int x, int y);
int main()
{
    int a = 0;
    int b = 20;
    int sum = 0;
    sum = Add(a, b);
    printf("%d\n", sum);
    return 0;
}
//函数定义
int Add(int x, int y)
{
    int z = x + y;
    return z;
}

引入自己的文件，用双引号引入头文件   #include "test.h"

（2）函数定义

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

 

8. 函数递归

 （1）递归

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

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

#include<stdio.h>
int main()
{
    printf("hehe\n");//死循环、栈溢出--stack overflow
    //栈区                堆区                         静态区
    //局部变量、函数形参  动态开辟内存malloc calloc   全局变量static
    main();//自己调用自己，就是递归
    return 0;
}

（2）递归的两个必要条件

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

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

例1：（画图讲解）

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

例如： 输入：1234，输出 1 2 3 4

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//1234%10=4
//1234/10=123
void print(unsigned int n)//第1次1234；第2次123；12；1
{
    if (n > 9)
    {
        print(n / 10);//第1次123，第二次12
    }
    printf("%d ", n % 10);//1；返回上一次，2；3；4
}
int main()
{
    unsigned int num = 0;
    scanf("%u", &num);//1234
    //%u无符号整型
    print(num);//打印参数部分数字的每一位,1234
    //print(123) 4
    //printf(12) 3 4
    //print(1) 2 3 4
    return 0;
}

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

//创建strlen，求字符串的长度
#include <stdio.h>
#include<string.h>//strlen头文件
int main()
{
    char arr[] = "bit";
    printf("%d\n", strlen(arr));//3
    return 0;
}

 

//创建临时变量，求字符串的长度
#include <stdio.h>
int my_strlen(char* str)
//计算长度是整型，返回类型是int
//str为指针
{
    int count=0;//创建临时变量count
    while (*str != '\0')//不能用if,if不能再次判断
    //指针指向不为'\0'
    {
        count++;
        str++;
    }
    return count;   
}
int main()
{
    char arr[] = "bit";
    //['a']['b']['c']['\0']
    //通过strlen,计算长度为3
    //模拟实现一个strlen函数
    int len = my_strlen(arr);
    printf("len=%d\n", len);//len=3
    //arr传参，传递的数组首元素地址
    //即传递的是a的地址
    return 0;
}

 

//使用递归方法
#include <stdio.h>
//my_strlen("bit")
//1+my_strlen("it")
//1+1+my_strlen("t")
//1+1+1+my_strlen("")
//1+1+1+0=3
//大事化小
int my_strlen(const char* str)//1.bit；2.it;3.t；4.\0
{
    //递归
    if (*str != '\0')
        return 1 + my_strlen(str + 1);//1.调用;2.调用;3调用；5，1；6，1+1；7.1+1+1
    else
        return 0;//4.往回反
}
int main()
{
    char arr[] = "bit";
    //['b']['i']['t']['\0']
    int len = my_strlen(arr);
    printf("len=%d\n", len);//len=3
    return 0;
}

 

 （3）递归与迭代

• 递归：自己调用自己
• 迭代：重复（类似于循环）

例1：求n的阶乘。（不考虑溢出）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//循环
//int Fac1(int n)
//{
//    int i = 0;
//    int ret = 1;
//    for (i = 1; i <= n;i++)
//    {
//        ret *= i;
//    }
//    return ret;
//}
//递归
int Fac2(int n)
{
    if (n <= 1)
    return 1;
    else
        return n * Fac2(n - 1);

}
int main()
{
    int n = 0;
    int ret = 0;
    scanf("%d", &n);
    //ret = Fac1(n);
    ret = Fac2(n);//循环的方式
    printf("%d\n", ret);
    return 0;
}

例2：求求第n个斐波那契数（不考虑溢出）

 斐波那契数：前两个数之和为第三个（例如：1 1 2 3 5 8 13 21 34 55 ...）

• n<=2，Fib(n)=1
• n>2，Fib(n)=Fib(n-1)+Fib(n-2)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//通过公式计算，效率低
//造成大量重复计算
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;
    int ret = 0;
    scanf("%d", &n);
    ret = Fib(n);
    printf("ret=%d\n", ret);
    printf("count=%d\n",count);
    return 0;
}

优化

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//循环或迭代的方式
//倒着进行计算
int Fib(int n)
{
    int a = 1;
    int b = 1;
    int c = 1;
    while (n > 2)
    {
        c = a + b;
        //产生新的a、b，进行赋值
        a = b;
        b = c;
        n--;
    }
    return c;//n为1或2，这里执行，返回c=1
}
int main()
{
    int n = 0;
    int ret = 0;
    scanf("%d", &n);
    ret = Fib(n);
    printf("ret=%d\n", ret);
    //printf("count=%d\n",count);
    return 0;
}

思考：

1. 递归比非递归的形式更为清晰。

2. 迭代实现往往比递归实现效率更高，代码的可读性稍差

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