本篇前言
C語言有各種各樣的庫函式，呼叫它們需要參考相應的頭檔案，由于C語言庫函式較多，講解原理的話涉及內容龐雜，作為替代這里給出C語言庫函式（包括各種關鍵字）查詢的網址供大家參考，有條件的小伙伴建議下載MSDN軟體（相當于離線的知識站）輔助學習

C/C++官方知識站

拋開庫函式，本篇所講函式均為自定義函式

函式的定義

C語言中的庫函式眾多，但是僅僅是這些庫函式，遠遠不能滿足我們編程時對于函式的需求，所以我們需要學習自定義函式，自立門派，掌握自定義函式也有助于我們理解庫函式的運作原理，
我們如何創建一個函式呢？
一個基本的函式應當由函式名、回傳值型別、函式引數、函式體組成，函式名就是函式的名字，方便我們呼叫它，函式名要避免與庫函式、關鍵字、已經定義過的函式名重名，一個函式一般會有一個回傳值，可以理解為呼叫函式后產生的結果，它的資料型別就是回傳值型別（也可以沒有回傳值，此時回傳值型別為void），函式引數分為實際引數和形式引數，具體見后文，函式體就是我們函式中的內容，一般函式的回傳值用return關鍵字引出，寫成return+回傳值，如果有return陳述句，return陳述句就是函式結束的標志
定義函式語法：

回傳值型別 函式名 (形式引數)
{
函式體；
（ return 回傳值；）
}

給出有回傳值型別函式樣例：
寫一個函式可以判斷一個數是不是素數

#include<stdio.h>
#include<math.h>
int sushu(int x)
{
	int i = 0;
	for (i = 2; i <= sqrt(x); i++)
	{
		if (x % i == 0)
			return 0;
	}
	return 1;
}

上面的函式的意思就是：如果是素數就回傳1，不是就回傳0，需要注意的是，看似我們寫了兩個回傳值的陳述句，但實際上我們只可能在同一時間得到一個回傳值，當我們return 0時，函式已經結束，不會再執行下面的return 1，當我們return 1時，說明函式一次都沒有讀到return 0，關于函式體的意思，前文已經細致的講解了判斷素數的流程，不再贅述，
給出無回傳值型別函式樣例：

#include<stdio.h>
void hhh()
{
	printf("哈哈哈\n");
}

這個函式并沒有回傳任何值，但這不妨礙它是一個函式

函式的使用

函式宣告

函式必須先宣告再使用，宣告的意思就是告訴編譯器有這個函式的存在，然后我們才能使用它，函式的宣告和函式的定義是兩回事，函式宣告是讓函式存在的陳述句，函式定義是賦予函式意義的陳述句，
語法：

回傳值型別 函式名 （形式引數型別）；

用下面的例子來加深一下理解：

#include<stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int Add(int, int);
	printf("%d", Add(a, b));
}
int Add(int x, int y)
{
	return x + y;
}

程式都是進主函式開始，出主函式結束，由于我們的Add函式定義在主函式的后面，所以如果我們不事先宣告它，程式將面臨一次都沒有見過Add函式就要呼叫它的局面，那就會報錯（現在有些比較智能的編譯器已經不會報錯了，但是我們需要養成好的代碼風格，請堅持先宣告再使用的原則），
為什么我們平常寫函式一般都不需要宣告呢？因為如果函式在主函式之前定義的話，定義本身就是一種強有力的宣告：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 1;
	int b = 2;
	printf("%d", Add(a, b));
}

傳值呼叫

傳值呼叫是最基礎的函式使用方法，意思就是我們只是把引數的值傳給了函式，所以函式怎樣處理這個值是函式的事兒，并不會改變原函式中的引數值，我們在文章開始寫的判斷素數的函式就是傳值呼叫：

#include<stdio.h>
#include<stdio.h>
#include<math.h>
int sushu(int x)
{
	int i = 0;
	for (i = 2; i <= sqrt(x); i++)
	{
		if (x % i == 0)
			return 0;
	}
	return 1;
}
int main()
{
	int a = 0;
	printf("列印100-200間的素數：\n");
	for (a = 101; a < 200; a += 2)
	{
		if (sushu(a))
			printf("%d ", a);
	}
	return 0;
}

在上面這個程式中，a是負責傳給函式值的引數；x是我們在函式中定義的，作用域僅在這個函式內部的，負責接收a的值并執行函式中陳述句的引數，我們把a叫做實際引數，把x叫做形式引數，實際引數a和形式引數x是兩個不同的引數，它們在記憶體中會被分配不同的空間，所以實際引數a不會受到形式引數x的影響，而形式引數x由于有時需要接收實際引數a的值，所以會實際引數a的改變會影響形式引數x，我們可以把形式引數x當成實際引數a的一份臨時拷貝，

傳址呼叫

傳址呼叫的意思就是我們給函式傳的不是引數的值而是引數的地址，我們什么時候需要用到傳址呼叫呢？看下面的例子：
我們需要寫一個函式，它能夠交換輸入的兩個引數的值：

#include<stdio.h>
void change(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}
int main()
{
	int a = 1;
	int b = 2;
	change(a, b);
	printf("a=%d,b=%d", a, b);
}

這樣寫行不行呢？看一下結果：

這個函式呼叫是一個傳值呼叫，我們剛剛才說過，傳值呼叫中形式引數和實際引數是兩塊不同的空間，所以我們在函式中交換形式引數x和y的值并不會改變實際引數a和b的值，所以這樣寫是行不通的，
而如果我們使用傳址呼叫，借助指標，就可以很好的解決這一問題：

#include<stdio.h>
void change(int* x, int* y)
{
	int z = 0;
	z = *x;
	*x = *y;
	*y = z;
}
int main()
{
	int a = 1;
	int b = 2;
	change(&a, &b);
	printf("a=%d,b=%d", a, b);
}

在此指標的作用就可見一斑了：指標可以在任何地方任何時間通過地址找到指定的變數進行操作，我們也可以這樣總結傳值呼叫和傳址呼叫：函式內部需要對函式外部變數進行操作時用傳址呼叫，函式內部只需要借用函式外部變數的值的時候用傳值呼叫，
我們再練習一題：
撰寫一個函式讓傳入的引數+1（小伙伴們可以先嘗試著寫一下試試）

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

既然用到了指標，就不得不提一下指標使用中比較特殊的一類：陣列
陣列傳參，傳的不是陣列的所有元素，而是陣列首元素的地址
比如我們撰寫一個函式來輸出陣列的第二個元素：
寫法一：

#include<stdio.h>
int s(int* pa)
{
	int a = *(pa+1);
	printf("%d", a);
}
int main()
{
	int arr[10] = { 1,8989,3,4,5,6,7,8,9,10 };
	s(arr);
}

寫法二：

#include<stdio.h>
int s(int a[])
{
	printf("%d", a[1]);
}
int main()
{
	int arr[10] = { 1,8989,3,4,5,6,7,8,9,10 };
	s(arr);
}

把兩個寫法放到一張圖上對比分析一下：

所以陣列傳參，看似傳的是整個陣列，實際上傳的是陣列首元素的地址
不相信的話我們再做個實驗：

#include<stdio.h>
int s(int a[])
{
	printf("%d\n", a);
}
int main()
{
	int arr[10] = { 1,8989,3,4,5,6,7,8,9,10 };
	printf("%d\n", &arr[0]);
	printf("%d\n", arr);
	s(arr);
}

這下徹底證明了，列印陣列名實際上列印的是陣列首元素的地址、傳參時傳遞陣列名實際上傳遞的也是陣列首元素的地址，這仨完全是一個東西，是披著不同馬甲的同一只烏龜

嵌套呼叫

函式與函式的地位是平等的，所以函式是不能嵌套定義的，但是函式允許嵌套呼叫，嵌套呼叫的意思就是函式里套用函式
舉個例子：

#include<stdio.h>
void laugh1()
{
	int i = 0;
	for (i = 1; i <= 3; i++)
		printf("哈哈 ");
}
void laugh2()
{
	int j = 0;
	for (j = 1; j <= 3; j++)
	{
		laugh1();
		printf("\n");
	}
}
int main()
{
	laugh2();
	return 0;
}

主函式呼叫了laugh2函式，laugh2函式里又呼叫了laugh1函式，這就是函式的嵌套呼叫，

鏈式訪問

某個函式的回傳值作為了另一個函式的引數，這就是鏈式訪問，
舉例：
我們經常使用printf函式來列印一些東西，而printf是C語言的庫函式，這個函式的回傳值是什么呢？
通過查MSDN，我們發現printf列印出內容時的回傳值是所列印元素的個數：

知道了這個我們來自己計算一下下面這段鏈式訪問的代碼的輸出值：

int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	return 0;
}

答案是：

最內層的printf列印43，第二層的printf列印的是最內層printf的回傳值，也就是“43”這個內容的元素個數——2，最外層列印的是“2”這個內容的元素個數——1，所以會列印出4321這四個數

函式的遞回

什么是遞回

程式間接或直接的呼叫自身的演算法技巧就是遞回，如果不設定限制條件，遞回就會一直繼續
我們通過下面的gif感性的理解一下：

這個gif就是一種常見的遞回模型，但它是一個死遞回，而我們使用遞回必須避免出現死遞回的，那該怎么正確使用遞回技巧呢？我們來重點學習一下函式遞回，

函式遞回

引例：我們需要設計這樣一個程式，輸入任意一個數字，然后從最低位到最高位輸出它，比如輸入12345，輸出54321，該怎么做呢？我們把大問題拆解成小問題來看一下，拿到12345這個五位數，需要先輸出5，那我們用12345%10就能得到5了；然后1234%10就可以得到4，123%10就可以得到3…對于整型變數12345，12345/10就可以得到1234，1234/10就可以得到123…也就是說，我們每一輪只需要先將輸入數對10取模然后輸出這個結果，再讓函式引數/10得到下一輪的輸入數，值得一提的是，如果僅僅是這樣，函式會陷入死遞回，因為沒有幫助它跳出的觸發條件，那我們就設定一個針對輸入數的觸發條件，我們發現如果輸入數是1-9，也就是只有個位數，那么說明這就是最后一位了，到此就可以跳出遞回，
給出原碼：

#include<stdio.h>
void print(unsigned int n)
{
	printf("%d", n % 10);
	if (n > 9)
	{
		print(n / 10);
	}
}
int main()
{
	unsigned int num = 0;
	scanf("%u", &num);
	print(num);
	return 0;
}

遞回函式就是print函式，我們來剖析一下這個函式的運行程序

構建遞回結構有兩點需要注意：
1.遞回必須有能夠跳出遞回的觸發條件
2.遞回時必須不斷的趨近這個觸發條件
否則，我們的遞回很可能會變成死遞回

遞回時的堆疊溢位問題

有時候我們明明設定了跳出遞回的觸發條件，也確實在不斷逼近這個條件，而且理論上是可以跳出遞回的，但是程式仍然執行不了，比如我們看下面這個例子：

#include<stdio.h>
void print(int i)
{
	printf("%d\n", i);
	i++;
	if (i < 10000)
		print(i);
}
int main()
{
	int a = 0;
	print(a);
	return 0;
}

我們的程式按理來說會列印到10000然后跳出遞回，但是我們的電腦列印到4502就打不動了，例外提示為堆疊溢位，那什么是堆疊溢位呢？今天我們先簡單理解一下：
記憶體一般分為堆疊區、堆區、靜態區三部分，堆疊區主要用于存放區域變數、函式的形式引數等等，屬于臨時分配的空間，

而我們每次呼叫函式都會為它在堆疊區分配一塊臨時空間

結果就是堆疊區的空間不足，導致堆疊溢位了，我們一般在程式中是使用一個函式，分配一塊臨時空間，用完得到函式的結果以后就銷毀這塊空間，但是遞回函式比較龐大，幾行代碼可能就需要分配很多很多的空間，所以會出現堆疊溢位的現象，
教訓就是我們在使用遞回的時候不能遞回太深，

遞回與迭代

我們之前講的回圈結構就是一種迭代，迭代是什么呢？我們可以簡單的這樣理解：
A重復呼叫A自身就是遞回，A重復呼叫B就是迭代
遞回的特點就是可以用極少的陳述句描述龐大的程式程序，可以讓我們的代碼變得簡潔有力，迭代的特點是可讀性高，較容易理解，但是陳述句就會相對多，有的問題只能使用遞回，有的只能使用迭代，還有的既可以使用遞回也可以使用迭代，
舉個例子，我們都知道計算字串長度的C庫函式strlen，那我們能不能自己撰寫一個和它功能相同的函式my_strlen呢？
接下來分別用遞回和迭代演示做法：
迭代做法：

#include<stdio.h>
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "tianxiao719";
	printf("%d\n", my_strlen(arr));
	return 0;
}

遞回做法：

#include<stdio.h>
int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}
int main()
{
	char arr[] = "tianxiao719";
	printf("%d", my_strlen(arr));
}

函式其他使用技巧

分模塊書寫程式

函式在工程專案中最大的作用就是將大任務拆分成不同的任務塊，分配給不同的程式設計師，大家每個人完成自己的那部分，最后再整合呼叫就好了，
比如我們需要寫一個加減乘除的程式（假設都得用函式實作），目前有五位程式員abcde，a只會加法，b只會減法，c只會乘法，d只會除法，e啥都不會只會使用簡單的C語言語法，所以分工就是abcd程式員將自己那部分用函式實作以后讓e程式員整合
1.一般將函式的宣告和函式的定義分開寫，宣告放在頭檔案(.h)中，定義放在源檔案(.c)中
2.使用時需要先引頭檔案，語法是#include"頭檔案名.h"

以a程式員寫的源檔案和頭檔案為例：
宣告add函式

定義add函式

（圖中出現的陌生陳述句大家跳過就好，不影響我們理解今天講解的知識點）

使用靜態庫隱藏函式實作部分

將函式的定義與宣告分開單獨放在一個源檔案中還有一個用處就是可以隱藏函式實作部分，比如我們以后寫了一個程式，有一個懶惰的程式員想直接買來用，但是我們又不能直接給原碼，那該怎么辦呢？我們可以把這個程式寫成一個函式，將函式的宣告放在頭檔案中，將定義部分的檔案轉換成靜態庫，然后把頭檔案和靜態庫給客戶，這樣就做到了隱藏函式實作部分，但是函式還是可以正常使用了，
操作：右擊專案名-配置屬性-常規-配置型別-靜態庫-應用-確定-F5編譯

在目錄中就會生成靜態庫檔案

這個靜態庫檔案和頭檔案sub.h就是我們賣給客戶的檔案
那客戶怎么使用呢？只需要把這兩個檔案拷貝到自己解決方案下的檔案夾中，然后在解決方案中打開頭檔案sub.h再在程式中加上這一行代碼匯入靜態庫：

#pragma comment(lib,"sub.lib")

即可