1. 函數的概念

數學中我們其實就見過函數的概念，比如：一次函數 y=kx+b ，k和b都是常數，給一個任意的x，就得到一個y值。
其實在C語言也引入函數（function）的概念，有些翻譯為：子程序，子程序這種翻譯更加準確一些。
C語言中的函數就是一個完成某項特定的任務的一小代碼。這段代碼是有特殊的寫法和調用方法的。
C語言的程序其實是由無數個小的函數組合而成的，也可以說：?個大的計算任務可以分解成若干個較小的函數（對應較小的任務）完成。同時一個函數如果能完成某項特定任務的話，這個函數也是可以復用的，提升了開發軟件的效率。
在C語言中我們?般會見到兩類函數：
? 庫函數
?自定義函數

2. 庫函數

2.1 標準庫和頭文件

C語言標準中規定了C語言的各種語法規則，C語言并不提供庫函數；C語言的國際標準ANSI C規定了一些常用的函數的標準，被稱為標準庫，那不同的編譯器廠商根據ANSI提供的C語言標準就給出了一系列函數的實現。這些函數就被稱為庫函數。
我們前面內容中學到的 printf 、 scanf 都是庫函數，庫函數也是函數，不過這些函數已經是現成的，我們只要學會就能直接使用了。有了庫函數，?些常見的功能就不需要程序員自己實現了，?定程度提升了效率；同時庫函數的質量和執行效率上都更有保證。
各種編譯器的標準庫中提供了?系列的庫函數，這些庫函數根據功能的劃分，都在不同的頭文件中進行了聲明。
庫函數相關頭文件：https://zh.cppreference.com/w/c/header
有數學相關的，有字符串相關的，有日期相關的等，每?個頭文件中都包含了，相關的函數和類型等信息，庫函數的學習不用著急一次性全部學會，慢慢學習，各個擊破就行。

2.2 庫函數的使用方法

庫函數的學習和查看工具很多，比如：
C/C++官方的鏈接：https://zh.cppreference.com/w/c/header
cplusplus.com：https://legacy.cplusplus.com/reference/clibrary/

舉例：sqrt

double sqrt (double x);
//sqrt 是函數名
//x 是函數的參數，表?調?sqrt函數需要傳遞?個double類型的值
//double 是返回值類型 - 表?函數計算的結果是double類型的值

2.2.1 功能

Compute square root 計算平方根
Returns the square root of x.（返回平方根）

2.2.2 頭文件包含

庫函數是在標準庫中對應的頭文件中聲明的，所以庫函數的使用，務必包含對應的頭文件，不包含是可能會出現?些問題的。

2.2.3 實踐

#include <stdio.h>
#include <math.h>
int main()
{double d = 16.0;double r = sqrt(d);printf("%lf\n", r);return 0;
}

運行結果：

2.2.4 庫函數文檔的一般格式

1. 函數原型
2. 函數功能介紹
3. 參數和返回類型說明
4. 代碼舉例
5. 代碼輸出
6. 相關知識鏈接

3. 自定義函數

了解了庫函數，我們的關注度應該聚焦在自定義函數上，自定義函數其實更加重要，也能給程序員寫代碼更多的創造性。

3.1 函數的語法形式

其實自定義函數和庫函數是一樣的，形式如下：

ret_type fun_name(形式參數)
{
}

? ret_type 是函數返回類型
? fun_name 是函數名
? 括號中放的是形式參數
? {}括起來的是函數體
我們可以把函數想象成小型的一加工廠，工廠得輸入原材料，經過工廠加工才能生產出產品，那函數也是一樣的，函數一般會輸入一些值（可以是0個，也可以是多個），經過函數內的計算，得出結果。
? ret_type 是用來表示函數計算結果的類型，有時候返回類型可以是 void ，表示什么都不返回
? fun_name 是為了方便使用用函數；就像人的名字一樣，有了名字方便稱呼，函數有了名字方便調用，所以函數名盡量要根據函數的功能起的有意義。
? 函數的參數就相當于，工廠中送進去的原材料，函數的參數也可以是 void ，明確表示函數沒有參數。如果有參數，要交代清楚參數的類型和名字，以及參數個數。
? {}括起來的部分被稱為函數體，函數體就是完成計算的過程。

3.2 函數的舉例

舉個例子：
寫一個加法函數，完成2個整型變量的加法操作。

 #include <stdio.h>
int main()
{int a = 0;int b = 0;//輸?scanf("%d %d", &a, &b);//調?加法函數，完成a和b的相加//求和的結果放在r中//to do//輸出printf("%d\n", r);return 0;
}

我們根據要完成的功能，給函數取名：Add，函數Add需要接收2個整型類型的參數，函數計算的結果也是整型。
所以我們根據上述的分析寫出函數：

#include <stdio.h>
int 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);//調?加法函數，完成a和b的相加//求和的結果放在r中int r = Add(a, b);//輸出printf("%d\n", r);return 0;
}

Add函數也可以簡化為：

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

函數的參數部分需要交代清楚：參數個數，每個參數的類型是啥，形參的名字叫啥。
上面只是一個例子，未來我們是根據實際需要來設計函數，函數名、參數、返回類型都是可以靈活變化的。

4. 形參和實參

在函數使用的過程中，把函數的參數分為，實參和形參。
再看看我們前面寫的代碼：

#include <stdio.h>
int 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);//調?加法函數，完成a和b的相加//求和的結果放在r中int r = Add(a, b);//輸出printf("%d\n", r);return 0;
}

4.1 實參

在上面代碼中，第2~7行是 Add 函數的定義，有了函數后，再第17行調用Add函數的。
我們把第17行調用Add函數時，傳遞給函數的參數a和b，稱為實際參數，簡稱實參。
實際參數就是真實傳遞給函數的參數。

4.2 形參

在上面代碼中，第2行定義函數的時候，在函數名 Add 后的括號中寫的 x 和 y ，稱為形式參數，簡
稱形參。
為什么叫形式參數呢？實際上，如果只是定義了 Add 函數，而不去調用的話， Add 函數的參數 x
和 y 只是形式上存在的，不會向內存申請空間，不會真實存在的，所以叫形式參數。形式參數只有在
函數被調用的過程中為了存放實參傳遞過來的值，才向內存申請空間，這個過程就是形參的實例化。

4.3 實參和形參的關系

雖然我們提到了實參是傳遞給形參的，他們之間是有聯系的，但是形參和實參各自是獨立的內存空
間。
這個現象是可以通過調試來觀察的。請看下面的代碼和調試演示

#include <stdio.h>
int 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);//調?加法函數，完成a和b的相加//求和的結果放在r中int r = Add(a, b);//輸出printf("%d\n", r);return 0;
}

我們在調試的時候可以觀察到，x和y確實得到了a和b的值，但是x和y的地址和a和b的地址是不?樣
的，所以我們可以理解為形參是實參的?份臨時拷貝。

5. return語句

在函數的設計中，函數中經常會出現return語句，這里講?下return語句使用的注意事項。
? return后邊可以是?個數值，也可以是?個表達式，如果是表達式則先執行表達式，再返回表達式
的結果。
? return后邊也可以什么都沒有，直接寫 return; 這種寫法適合函數返回類型是void的情況。
? return返回的值和函數返回類型不?致，系統會自動將返回的值隱式轉換為函數的返回類型。
? return語句執行后，函數就徹底返回，后邊的代碼不再執行。
? 如果函數中存在if等分支的語句，則要保證每種情況下都有return返回，否則會出現編譯錯誤。

6. 數組做函數參數

在使用函數解決問題的時候，難免會將數組作為參數傳遞給函數，在函數內部對數組進行操作。
比如：寫?個函數對將?個整型數組的內容，全部置為-1，再寫?個函數打印數組的內容。
簡單思考?下，基本的形式應該是這樣的：

#include <stdio.h>
int main()
{int arr[] = {1,2,3,4,5,6,7,8,9,10};set_arr();//設置數組內容為-1print_arr();//打印數組內容return 0;
}

這里的set_arr函數要能夠對數組內容進行設置，就得把數組作為參數傳遞給函數，同時函數內部在設
置數組每個元素的時候，也得遍歷數組，需要知道數組的元素個數。所以我們需要給set_arr傳遞2個參
數，一個是數組，另外一個是數組的元素個數。仔細分析print_arr也是一樣的，只有拿到了數組和元
素個數，才能遍歷打印數組的每個元素。

#include <stdio.h>
int main()
{int arr[] = {1,2,3,4,5,6,7,8,9,10};int sz = sizeof(arr)/sizeof(arr[0]);set_arr(arr, sz);//設置數組內容為-1print_arr(arr, sz);//打印數組內容return 0;
}

數組作為參數傳遞給了set_arr 和 print_arr 函數了，那這兩個函數應該如何設計呢？
這里我們需要知道數組傳參的幾個重點知識：
? 函數的形式參數要和函數的實參個數匹配
? 函數的實參是數組，形參也是可以寫成數組形式的
? 形參如果是一維數組，數組大小可以省略不寫
? 形參如果是二維數組，行可以省略，但是列不能省略
? 數組傳參，形參是不會創建新的數組的
? 形參操作的數組和實參的數組是同一個數組

根據上述的信息，我們就可以實現這兩個函數：

void set_arr(int arr[], int sz)
{int i = 0;for(i=0; i<sz; i++){arr[i] = -1;}
}
void print_arr(int arr[], int sz)
{int i = 0;for(i=0; i<sz; i++){printf("%d ", arr[i]);}printf("\n");
}

7. 嵌套調和鏈式訪問

7.1 嵌套調用

嵌套調用就是函數之間的互相調用，每個函數就行?個樂高零件，正是因為多個樂高的零件互相無縫
的配合才能搭建出精美的樂高玩具，也正是因為函數之間有效的互相調用，最后寫出來了相對大型的
程序。
假設我們計算某年某月有多少天？如果要函數實現，可以設計2個函數:
? is_leap_year()：根據年份確定是否是閏年
? get_days_of_month()：調?is_leap_year確定是否是閏年后，再根據月計算這個月的天數

int is_leap_year(int y)
{if(((y%4==0)&&(y%100!=0))||(y%400==0))return 1;elsereturn 0;
}
int get_days_of_month(int y, int m)
{int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};int day = days[m];if (is_leap_year(y) && m == 2)day += 1;return day;
}
int main()
{int y = 0;int m = 0;scanf("%d %d", &y, &m);int d = get_days_of_month(y, m);printf("%d\n", d);return 0;
}

這一段代碼，完成了一個獨立的功能。代碼中反應了不少的函數調用：
? main 函數調用 scanf 、 printf 、 get_days_of_month
? get_days_of_month 函數調用 is_leap_year
未來的稍微大一些代碼都是函數之間的嵌套調用，但是函數是不能qian套定義的。

7.2 鏈式訪問

所謂鏈式訪問就是將一個函數的返回值作為另外一個函數的參數，像鏈條一樣將函數串起來就是函數
的鏈式訪問。
比如：

#include <stdio.h>
int main()
{int len = strlen("abcdef");//1.strlen求?個字符串的?度printf("%d\n", len);//2.打印?度 return 0;
}

前面的代碼完成動作寫了2條語句，把如果把strlen的返回值直接作為printf函數的參數呢？這樣就是一
個鏈式訪問的例子了。

#include <stdio.h>
int main()
{printf("%d\n", strlen("abcdef"));//鏈式訪問return 0;}

在看一個有趣的代碼，下面代碼執行的結果是什么呢？

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

這個代碼的關鍵是明白 printf 函數的返回是啥？

int printf ( const char * format, ... );

printf函數返回的是打印在屏幕上的字符的個數。
上面的例子中，我們就第一個printf打印的是第二個printf的返回值，第二個printf打印的是第三個
printf的返回值。
第三個printf打印43，在屏幕上打印2個字符，再返回2
第二個printf打印2，在屏幕上打印1個字符，再放回1
第一個printf打印1
所以屏幕上最終打印：4321

8. 函數的聲明和定義

8.1 單個文件

一般我們在使用函數的時候，直接將函數寫出來就使用了。
比如：我們要寫一個函數判斷一年是否是閏年。

#include <stido.h>
//判斷?年是不是閏年
int is_leap_year(int y)
{if(((y%4==0)&&(y%100!=0)) || (y%400==0))return 1;elsereturn 0;
}
int main()
{int y = 0;scanf("%d", &y);int r = is_leap_year(y);if(r == 1)printf("閏年\n");elseprintf("?閏年\n");return 0;
}

上面代碼中橙色的部分是函數的定義，綠色的部分是函數的調用。
這種場景下是函數的定義在函數調用之前，沒啥問題。
那如果我們將函數的定義放在函數的調用后邊，如下：

#include <stido.h>
int main()
{int y = 0;scanf("%d", &y);int r = is_leap_year(y);if(r == 1)printf("閏年\n");elseprintf("?閏年\n");return 0;
}
//判斷?年是不是閏年
int is_leap_year(int y)
{if(((y%4==0)&&(y%100!=0)) || (y%400==0))return 1;elsereturn 0;
}

這個代碼在VS2022上編譯，會出現下面的警告信息：

這是因為C語言編譯器對源代碼進行編譯的時候，從第一行往下掃描的，當遇到第7行的is_leap_year
函數調用的時候，并沒有發現前面有is_leap_year的定義，就報出了上述的警告。
把怎么解決這個問題呢？就是函數調用之前先聲明?下is_leap_year這個函數，聲明函數只要交代清
楚：函數名，函數的返回類型和函數的參數。
如：int is_leap_year(int y)；這就是函數聲明，函數聲明中參數只保留類型，省略掉名字也是可以
的。

代碼變成這樣就能正常編譯了:

#include <stido.h>
int is_leap_year(int y)；//函數聲明
int main()
{int y = 0;scanf("%d", &y);int r = is_leap_year(y);if(r == 1)printf("閏年\n");elseprintf("?閏年\n");return 0;
}//判斷?年是不是閏年int is_leap_year(int y)
{if(((y%4==0)&&(y%100!=0)) || (y%400==0))return 1;else
return 0;}

函數的調用?定要滿足，先聲明后使用；
函數的定義也是一種特殊的聲明，所以如果函數定義放在調用之前也是可以的。

8.2 多個文件

一般在企業中我們寫代碼時候，代碼可能比較多，不會將所有的代碼都放在?個文件中；我們往往會
根據程序的功能，將代碼拆分放在多個文件中。
一般情況下，函數的聲明、類型的聲明放在頭文件（.h）中，函數的實現是放在源文件（.c）文件中。
如下：
add.c

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

add.h

1 //函數的聲明
2 int Add(int x, int y);

test.c

#include <stdio.h>#include "add.h"int main(){int a = 10;int b = 20;//函數調?int c = Add(a, b);printf("%d\n", c);return 0;
}

有了函數聲明和函數定義的理解，我們寫代碼就更加方便了。

8.3 static 和 extern

static 和 extern 都是C語言中的關鍵字。
static 是 靜態的 的意思，可以用來：
? 修飾局部變量
? 修飾全局變量
? 修飾函數
extern 是用來聲明外部符號的。
在講解 static 和 extern 之前再講?下：作用域和生命周期。
作用域（scope）是程序設計概念，通常來說，?段程序代碼中所用到的名字并不總是有效（可用）
的，而限定這個名字的可用性的代碼范圍就是這個名字的作用域。
1. 局部變量的作用域是變量所在的局部范圍。
2. 全局變量的作用域是整個工程（項目）。
生命周期指的是變量的創建(申請內存)到變量的銷毀(收回內存)之間的?個時間段。
1. 局部變量的生命周期是：進入作用域變量創建，生命周期開始，出作用域生命周期結束。
2. 全局變量的生命周期是：整個程序的生命周期

8.3.1 static 修飾局部變量：

//代碼1
#include <stdio.h>
void test()
{int i = 0;i++;printf("%d ", i);
}
int main()
{int i = 0;for(i=0; i<5; i++){test();}return 0;
}

//代碼2
#include <stdio.h>
void test()
{//static修飾局部變量static int i = 0;i++;printf("%d ", i);
}
int main()
{int i = 0;for(i=0; i<5; i++){test();}return 0;
}

對比代碼1和代碼2的效果，理解 static 修飾局部變量的意義。
代碼1的test函數中的局部變量i是每次進入test函數先創建變量（生命周期開始）并賦值為0，然后
++，再打印，出函數的時候變量生命周期將要結束（釋放內存）。
代碼2中，我們從輸出結果來看，i的值有累加的效果，其實 test函數中的i創建好后，出函數的時候是
不會銷毀的，重新進入函數也就不會重新創建變量，直接上次累積的數值繼續計算。
結論：static修飾局部變量改變了變量的生命周期，生命周期改變的本質是改變了變量的存儲類型，本
來?個局部變量是存儲在內存的棧區的，但是被 static 修飾后存儲到了靜態區。存儲在靜態區的變
量和全局變量是?樣的，生命周期就和程序的生命周期?樣了，只有程序結束，變量才銷毀，內存才
回收。但是作用域不變的。

使用建議：未來一個變量出了函數后，我們還想保留值，等下次進入函數繼續使用，就可以使用static
修飾。

8.3.2 static 修飾全局變量

代碼1:
add.c

1 int g_val = 2018;

test.c

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

代碼2
add.c

1 static int g_val = 2018;

test.c

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

extern 是用來聲明外部符號的，如果?個全局的符號在A文件中定義的，在B文件中想使用，就可以使
用extern 進行聲明，然后使用。
代碼1正常，代碼2在編譯的時候會出現鏈接性錯誤。
結論：
?個全局變量被static修飾，使得這個全局變量只能在本源文件中想使用 ，只要適當的聲明就可以使
用；但是全局變量被 static 修飾之后，外部鏈接屬性就變成了內部鏈接屬性，只能在自己所在的源
文件內部使用了，其他源文件，即使聲明了，也是無法正常使用的。
使用建議：如果一個全局變量，只想在所在的源文件內部使用，不想被其他文件發現，就可以使用
static修飾。

8.3.3 static 修飾函數

代碼1:
add.c

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

test.c

#include <stdio.h>
extern int Add(int x, int y);
int main()
{printf("%d\n", Add(2, 3));return 0;
}

代碼2:
add.c

static int Add(int x, int y)
{return x+y;
}

test.c

#include <stdio.h>
extern int Add(int x, int y);
int main()
{printf("%d\n", Add(2, 3));return 0;
}

代碼1是能夠正常運行的，但是代碼2就出現了鏈接錯誤。
其實 static 修飾函數和 static 修飾全局變量是?模?樣的，一個函數在整個工程都可以使用，被static修飾后，只能在本文件內部使用，其他文件無法正常的鏈接使用了。
本質是因為函數默認是具有外部鏈接屬性，具有外部鏈接屬性，使得函數在整個工程中只要適當的聲
明就可以被使?。但是被 static 修飾后變成了內部鏈接屬性，使得函數只能在自己所在源問你件內部
使用。
使用建議：?個函數只想在所在的源文件內部使用，不想被其他源文件使?，就可以使用 static 修
飾。