第三章-函數

一、函數

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. 當一個問題相當復雜，難以用迭代實現時，遞歸簡潔性可以補償它所帶來的運行時開銷。