函數傳參：

1、形參變量屬于它所在的函數，出了該函數就不能使用
2、實參與形參之間都是以賦值的形式進行數據傳遞（值傳遞）
3、return 其實是把返回值數據放置到一個公共的區域（函數和函數調用者），如果不寫return語句，那么該區域中就是一個隨機的垃圾數據
4、數組作為函數參數傳遞時，長度會丟失，需要額外增加一個變量把數組的長度也傳遞過去。
5、函數之間，數組的傳遞時址傳遞，函數與函數的調用者可以共享數組

練習1：實現一個函數，找出數組中的最大值

#include<stdio.h>int func(int a[],int len)
{int max=a[0];for(int i=1;i<len;i++){if(max<a[i])max=a[i];	}return max;
}int main(int argc,const char* argv[])
{int a[10]={0,1,2,3,4,5,6,7,8,155};int max= func(a,sizeof(a)/sizeof(a[0]));printf("%d",max);
}

練習2：實現一個函數，對數組進行排序

#include<stdio.h>void func(int a[],int len)
{int change;for(int i=0;i<len;i++){for(int j=i+1;j<len;j++){if(a[i]>a[j]){change=a[i];a[i]=a[j];a[j]=change;}}}
}int main(int argc,const char* argv[])
{int a[10]={15,95,18,19,47,85,63,25,98,46};int len=sizeof(a)/sizeof(a[0]);func(a,len);for(int i=0;i<len;i++){printf("%d ",a[i]);	}
}

練習3：實現一個函數，查找數組中是否存在某個值，如果存在，則返回該數據在數組中的下標，否則返回-1

#include<stdio.h>int func(int a[],int len,int n)
{for(int i=0;i<len;i++){if(a[i]==n)return i;	}return -1;
}int main(int argc,const char* argv[])
{int a[10]={0,2,1,3,4,5,6,7,8,9};int len=sizeof(a)/sizeof(a[0]);int ret=func(a,len,1);if(ret)printf("%d",ret);else printf("none");
}

設計函數時的準則：

1、一個函數最好只解決一個問題，這樣可以降低出錯率，提高可讀性。
2、最好不要依賴其他函數。（降低耦合性）
3、數據由調用者提供，結果返回給調用者（提高通用性）
4、要考慮調用者提供的非法數據，可以通過返回值方式告訴調用者，或者把可能出現的情況通過注釋的方式寫明白（健壯性）

進程映像：

程序：儲存在磁盤上的可執行文件(二進制文件、腳本文件)
進程：正在系統中運行的程序
進程映像：指的是進程內存的分布情況text    代碼段： 存儲二進制指令、常量，權限是只讀，強制修改會產生段錯誤
data    數據段： 存儲初始化過的全局變量、初始化過的靜態局部變量
bss     靜態數據段： 存儲未初始化過的全局變量，未初始化過的靜態局部變量，程序運行時會被清理為0   
stack   棧： 存儲局部變量、塊變量，會隨著程序運行不斷申請、釋放，由操作系統管理，小
heap    堆： 由程序猿手動管理，足夠大

局部變量和全局變量：

局部變量： 定義在函數內存儲位置： stack 棧生命周期： 函數調用開始直到知道函數執行結束使用范圍： 函數內使用全局變量： 定義在函數外存儲位置： data（初始化）、bss（未初始化）生命周期： 運行前就定義完成，程序結束才釋放適用范圍： 程序的任何位置都可以使用塊變量： 定義在語句塊內的 if{} for(){} while(){}存儲位置： stack 棧生命周期： 函數調用開始直到知道函數執行結束使用范圍： 只能在語句塊內使用
注意：1、局部變量可以和全局變量同名但是會屏蔽同名的全局變量，同名塊變量也會屏蔽同名的全局變量和局部變量2、建議全局變量首字母大寫

存儲介質：

硬盤->內存->高級緩存->寄存器

類型限定符：

auto：  用于定義自動申請、自動釋放內存的變量（局部變量），不加就代表加注意：全局變量不能用auto修飾C11標準中auto用于自動類型識別auto num =3.14
extern： 聲明變量，意思是說明此變量已在別處定義過了，請放心使用。但是只能臨時通過編譯，鏈接時找不到該變量，依然會報錯聲明時不可賦值
static：被它修飾過的局部變量叫靜態局部變量改變存儲位置：改變局部變量的儲存位置，由stack改到data或bss（由是否初始化決定改到那個段）延長生命周期： 延長局部變量的生命周期限制作用域：限制全局變量、函數只能在本文件中使用，可以防止全局變量、函數被別人調用可以防止防止命名沖突 
const:“保護”變量不被顯示地修改注意：如果對初始化過的全局變量、初始化過的靜態局部變量使用const修飾，那么存儲位置會變成text
volatile:如果變量值沒有顯示地改變，那么在使用這個變量時，不會從內存中讀取，而是繼續用上次讀取的結果，這叫編譯器的取值優化。如果變量被volatile修飾后，每次使用該變量時，不做取值優化，每次都從內存中讀取。一般在硬件編程、多線程編程時經常使用
register：申請把變量的存儲介質由內存改為寄存器。但是由于寄存器有限，所以不一定能申請成功注意：寄存器變量不允許獲取地址
typedef：類型重定義，定義變量前如果加入typedef，那么變量名就變成了這個類型注意：不是替換關系#define num int     替換typedef int num;    類型重定義從使用角度看一樣

遞歸：

函數自己調用自己的行為，有可能會造成死循環
遞歸可以實現分治這種算法，就是把一個復雜的大問題，分解成若干個相同的小問題，直到問題解決1、出口問題2、解決一個小問題3、調用自己計算出第n個斐波那契數列
int func(int n)
{if(1== n||2 == n) return 1;return func(n-1)+func(n-2);
}
1 1 2 3 5 8 13.......遞歸函數每調用一次都會在棧內產生一份自己的拷貝，直到到達出口，才會一層一層的釋放，因此使用遞歸時非常耗費內存，
與循環相比速度非常慢，能使用循環解決就用循環解決。不要試圖分解遞歸的過程遞歸優缺點：1、耗內存、速度慢2、好理解、思路清晰3、可以解決非線性的執行過程

作業：

1、用編程模擬漢諾塔的移動過程

#include<stdio.h>void show(char a,char c,int n)
{printf("%d %c->%c\n",n,a,c);	
}void func(int n,char a,char b,char c)
{if(n==1)show(a,c,n);else{func(n-1,a,c,b);show(a,c,n);func(n-1,b,a,c);}
}int main(int argc,const char* argv[])
{int n;scanf("%d",&n);func(n,'A','B','C');return 0;
}

2、輸入一個整數，計算出0~9每個數字出現幾次

#include<stdio.h>void func(int n,char a[])
{if(n==0)return;a[n%10]++;func(n/10,a);
}int main(int argc,const char* argv[])
{int n;scanf("%d",&n);char a[10]={};func(n,a);for(int i=0;i<10;i++){printf("%hhd:%hhd ",i,a[i]);	}
}