全面匯總｜你不能不知道的C語言知識

C語言一經(jīng)出現(xiàn)就以其功能豐富、表達(dá)能力強、靈活方便、應(yīng)用面廣等特點迅速在全世界普及和推廣。C語言也是其它眾多高級語言的鼻祖語言，所以說學(xué)習(xí)C語言是進(jìn)入編程世界的必修課。

C語言不但執(zhí)行效率高而且可移植性好，可以用來開發(fā)應(yīng)用軟件、驅(qū)動、操作系統(tǒng)等。

hello,world

#include<stdio.h> 
int main(){
    /*在雙引號中間輸入Hello World*/ 
    printf("Hello World");
    return 0; 
}

注：在最新的C標(biāo)準(zhǔn)中，main函數(shù)前的類型為int而不是void

c語言的具體結(jié)構(gòu)

簡單來說，一個C程序就是由若干頭文件和函數(shù)組成。

#include <stdio.h>就是一條預(yù)處理命令, 它的作用是通知C語言編譯系統(tǒng)在對C程序進(jìn)行正式編譯之前需做一些預(yù)處理工作。

• 函數(shù)就是實現(xiàn)代碼邏輯的一個小的單元。

必不可少之主函數(shù)

一個C程序有且只有一個主函數(shù)，即main函數(shù)。

C程序就是執(zhí)行主函數(shù)里的代碼，也可以說這個主函數(shù)就是C語言中的唯一入口。

• 而main前面的int就是主函數(shù)的類型.

• printf()是格式輸出函數(shù)，這里就記住它的功能就是在屏幕上輸出指定的信息

• return是函數(shù)的返回值，根據(jù)函數(shù)類型的不同，返回的值也是不同的。

• n是轉(zhuǎn)義字符中的換行符。(注意：C程序一定是從主函數(shù)開始執(zhí)行的)

良好習(xí)慣之規(guī)范

1. 一個說明或一個語句占一行，例如：包含頭文件、一個可執(zhí)行語句結(jié)束都需要換行。
2. 函數(shù)體內(nèi)的語句要有明顯縮進(jìn)，通常以按一下Tab鍵為一個縮進(jìn)。
3. 括號要成對寫，如果需要刪除的話也要成對刪除。
4. 當(dāng)一句可執(zhí)行語句結(jié)束的時候末尾需要有分號。
5. 代碼中所有符號均為英文半角符號。

注釋是寫給程序員看的，不是寫給電腦看的。

C語言注釋方法有兩種：

多行注釋： /* 注釋內(nèi)容 */

單行注釋： //注釋一行

有名有姓的C(標(biāo)識符)

C語言規(guī)定，標(biāo)識符可以是字母(A～Z，a～z)、數(shù)字(0～9)、下劃線_組成的字符串，并且第一個字符必須是字母或下劃線。在使用標(biāo)識符時還有注意以下幾點：

標(biāo)識符的長度最好不要超過8位，因為在某些版本的C中規(guī)定標(biāo)識符前8位有效，當(dāng)兩個標(biāo)識符前8位相同時，則被認(rèn)為是同一個標(biāo)識符。

1. 標(biāo)識符是嚴(yán)格區(qū)分大小寫的。例如Imooc和imooc 是兩個不同的標(biāo)識符。

2. 標(biāo)識符最好選擇有意義的英文單詞組成做到"見名知意"，不要使用中文。

3. 標(biāo)識符不能是C語言的關(guān)鍵字。想了解更多C語言關(guān)鍵字的知識。

變量及賦值

變量就是可以變化的量，而每個變量都會有一個名字（標(biāo)識符）。變量占據(jù)內(nèi)存中一定的存儲單元。使用變量之前必須先定義變量，要區(qū)分變量名和變量值是兩個不同的概念。

變量定義的一般形式為：數(shù)據(jù)類型 變量名;

多個類型相同的變量：數(shù)據(jù)類型 變量名, 變量名, 變量名...;

注意:在定義中不允許連續(xù)賦值，如int a=b=c=5;是不合法的。

變量的賦值分為兩種方式:

1. 先聲明再賦值

2. 聲明的同時賦值

基本數(shù)據(jù)類型

C語言中，數(shù)據(jù)類型可分為：

1. 基本數(shù)據(jù)類型
2. 構(gòu)造數(shù)據(jù)類型
3. 指針類型
4. 空類型四大類

最常用的整型, 實型與字符型(char,int,float,double):

整型數(shù)據(jù)是指不帶小數(shù)的數(shù)字(int,short int,long int, unsigned int, unsigned short int,unsigned long int):

• intshort intlong int是根據(jù)編譯環(huán)境的不同，所取范圍不同。

• 而其中short int和long int至少是表中所寫范圍, 但是int在表中是以16位編譯環(huán)境寫的取值范圍。

• 另外 c語言int的取值范圍在于他占用的字節(jié)數(shù) ，不同的編譯器，規(guī)定是不一樣。

• ANSI標(biāo)準(zhǔn)定義int是占2個字節(jié)，TC是按ANSI標(biāo)準(zhǔn)的，它的int是占2個字節(jié)的。但是在VC里，一個int是占4個字節(jié)的。

浮點數(shù)據(jù)是指帶小數(shù)的數(shù)字。

生活中有很多信息適合使用浮點型數(shù)據(jù)來表示，比如：人的體重(單位：公斤)、商品價格、圓周率等等。

因為精度的不同又分為3種(float,double,long double)：

注：C語言中不存在字符串變量，字符串只能存在字符數(shù)組中,這個后面會講。

格式化輸出語句

當(dāng)輸出語句中包含普通字符時，可以采用一下格式：

printf("普通字符輸出格式符", 輸出項);

注意：格式符的個數(shù)要與變量、常量或者表達(dá)式的個數(shù)一一對應(yīng)

不可改變的常量

在程序執(zhí)行過程中，值不發(fā)生改變的量稱為常量。

mtianyan: C語言的常量可以分為直接常量和符號常量。

• 直接常量也稱為字面量，是可以直接拿來使用，無需說明的量，比如：

• 整型常量：13、0、-13；

• 實型常量：13.33、-24.4；

• 字符常量：‘a(chǎn)’、‘M’

• 字符串常量：”I love imooc!”

在C語言中，可以用一個標(biāo)識符來表示一個常量，稱之為符號常量。符號常量在使用之前必須先定義，其一般形式為：

#define 標(biāo)識符 常量值

#include <stdio.h>
#define POCKETMONEY 10    //定義常量及常量值
int main(){
    // POCKETMONEY = 12;  //小明私自增加零花錢對嗎？
    printf("小明今天又得到%d元零花錢n", POCKETMONEY);
    return 0;  
}

符號常量不可以被改變。

自動類型轉(zhuǎn)換

數(shù)據(jù)類型存在自動轉(zhuǎn)換的情況。
自動轉(zhuǎn)換發(fā)生在不同數(shù)據(jù)類型運算時，在編譯的時候自動完成。

char類型數(shù)據(jù)轉(zhuǎn)換為int類型數(shù)據(jù)遵循ASCII碼中的對應(yīng)值.

注:

字節(jié)小的可以向字節(jié)大的自動轉(zhuǎn)換，但字節(jié)大的不能向字節(jié)小的自動轉(zhuǎn)換

char可以轉(zhuǎn)換為int，int可以轉(zhuǎn)換為double，char可以轉(zhuǎn)換為double。但是不可以反向。

強制類型轉(zhuǎn)換

強制類型轉(zhuǎn)換是通過定義類型轉(zhuǎn)換運算來實現(xiàn)的。其一般形式為：

(數(shù)據(jù)類型) (表達(dá)式)

1. 數(shù)據(jù)類型和表達(dá)式都必須加括號, 如把(int)(x/2+y)寫成(int)x/2+y則成了把x轉(zhuǎn)換成int型之后再除2再與y相加了。
2. 轉(zhuǎn)換后不會改變原數(shù)據(jù)的類型及變量值，只在本次運算中臨時性轉(zhuǎn)換。
3. 強制轉(zhuǎn)換后的運算結(jié)果不遵循四舍五入原則。

運算符號

C語言中運算符:

※ 算術(shù)運算符
※ 賦值運算符
※ 關(guān)系運算符
※ 邏輯運算符
※ 三目運算符

算術(shù)運算符

c語言基本運算符:

除法運算中注意：

如果相除的兩個數(shù)都是整數(shù)的話，則結(jié)果也為整數(shù)，小數(shù)部分省略，如8/3 = 2;

而兩數(shù)中有一個為小數(shù)，結(jié)果則為小數(shù)，如：9.0/2 = 4.500000。

mtianyan: 取余運算中注意：

該運算只適合用兩個整數(shù)進(jìn)行取余運算，如：10%3 = 1；

mtianyan: notes: 而10.0%3則是錯誤的；運算后的符號取決于被模數(shù)的符號，如(-10)%3 = -1;而10%(-3) = 1;

mtianyan: %%表示這里就是一個%符.

注：C語言中沒有乘方這個運算符，也不能用×, ÷等算術(shù)符號。

自增與自減運算符

• 自增運算符為++，其功能是使變量的值自增1

• 自減運算符為--，其功能是使變量值自減1。

它們經(jīng)常使用在循環(huán)中。自增自減運算符有以下幾種形式：

賦值運算符

C語言中賦值運算符分為簡單賦值運算符和復(fù)合賦值運算符

簡單賦值運算符=號了，下面講一下復(fù)合賦值運算符：

復(fù)合賦值運算符就是在簡單賦值符=之前加上其它運算符構(gòu)成.

例如+=、-=、*=、/=、%=

分析：定義整型變量a并賦值為3，a += 5;這個算式就等價于a = a+5; 將變量a和5相加之后再賦值給a

注意：復(fù)合運算符中運算符和等號之間是不存在空格的。

關(guān)系運算符

C語言中的關(guān)系運算符:

關(guān)系表達(dá)式的值是真和假，在C程序用整數(shù)1和0表示。

注意：>=, <=, ==, !=這種符號之間不能存在空格。

邏輯運算符

C語言中的邏輯運算符:

邏輯運算的值也是有兩種分別為真和假，C語言中用整型的1和0來表示。其求值規(guī)則如下：

• 與運算 &&

參與運算的兩個變量都為真時，結(jié)果才為真，否則為假。例如：5>=5 && 7>5 ，運算結(jié)果為真；

• 或運算 ||

參與運算的兩個變量只要有一個為真，結(jié)果就為真。兩個量都為假時，結(jié)果為假。例如：5>=5||5>8，運算結(jié)果為真；

• 非運算!

參與運算的變量為真時，結(jié)果為假；參與運算量為假時，結(jié)果為真。例如：!(5>8)，運算結(jié)果為真。

三目運算符

C語言中的三目運算符：?:，其格式為：

表達(dá)式1 ? 表達(dá)式2 : 表達(dá)式3;

執(zhí)行過程是：

先判斷表達(dá)式1的值是否為真，如果是真的話執(zhí)行表達(dá)式2；如果是假的話執(zhí)行表達(dá)式3。

#include <stdio.h>
int main(){
    //定義小編兜里的錢
    double money =12.0      ; 
    //定義打車回家的費用
    double cost =11.5       ;  
    printf("小編能不能打車回家呢："); 
    //輸出y小編就打車回家了，輸出n小編就不能打車回家
    printf("%cn",money>=cost?'y':'n'                        );
    return 0;
}

運算符大比拼之優(yōu)先級比較

各種運算符號的順序:

優(yōu)先級別為1的優(yōu)先級最高，優(yōu)先級別為10的優(yōu)先級別最低。

分支結(jié)構(gòu)之簡單if語句

C語言中的分支結(jié)構(gòu)語句中的if條件語句。

簡單if語句的基本結(jié)構(gòu)如下：

if(表達(dá)式)
{
  執(zhí)行代碼塊;
}

其語義是：如果表達(dá)式的值為真，則執(zhí)行其后的語句，否則不執(zhí)行該語句。

注意：if()后面沒有分號，直接寫{}

分支結(jié)構(gòu)之簡單if-else語句

簡單的if-else語句的基本結(jié)構(gòu):

語義是: 如果表達(dá)式的值為真，則執(zhí)行代碼塊1，否則執(zhí)行代碼塊2。

注意：

if()后面沒有分號，直接寫{},else后面也沒有分號，直接寫{}

分支結(jié)構(gòu)之多重if-else語句

C語言中多重if-else語句，其結(jié)構(gòu)如下：

語義是：依次判斷表達(dá)式的值，當(dāng)出現(xiàn)某個值為真時，則執(zhí)行對應(yīng)代碼塊，否則執(zhí)行代碼塊n。

注意：當(dāng)某一條件為真的時候，則不會向下執(zhí)行該分支結(jié)構(gòu)的其他語句。

分支結(jié)構(gòu)之嵌套if-else語句

循環(huán)結(jié)構(gòu)之while循環(huán)

反復(fù)不停的執(zhí)行某個動作就是江湖人稱的循環(huán) 。

C語言中有三種循環(huán)結(jié)構(gòu),先看一下C語言while循環(huán)的結(jié)構(gòu)

其中表達(dá)式表示循環(huán)條件，執(zhí)行代碼塊為循環(huán)體。

while語句的語義是：計算表達(dá)式的值，當(dāng)值為真(非0)時， 執(zhí)行循環(huán)體代碼塊。

1. while語句中的表達(dá)式一般是關(guān)系表達(dá)或邏輯表達(dá)式，當(dāng)表達(dá)式的值為假時不執(zhí)行循環(huán)體，反之則循環(huán)體一直執(zhí)行。

2. 一定要記著在循環(huán)體中改變循環(huán)變量的值，否則會出現(xiàn)死循環(huán)（無休止的執(zhí)行）。

3. 循環(huán)體如果包括有一個以上的語句，則必須用{}括起來，組成復(fù)合語句。

循環(huán)結(jié)構(gòu)之do-while循環(huán)

C語言中的do-while循環(huán)，一般形式如下：

do-while循環(huán)語句的語義是:

它先執(zhí)行循環(huán)中的執(zhí)行代碼塊，然后再判斷while中表達(dá)式是否為真，如果為真則繼續(xù)循環(huán)；如果為假，則終止循環(huán)。因此，do-while循環(huán)至少要執(zhí)行一次循環(huán)語句。

注意：mtianyan: 使用do-while結(jié)構(gòu)語句時，while括號后必須有分號。

循環(huán)結(jié)構(gòu)之for循環(huán)(一)

c語言中for循環(huán)一般形式：

它的執(zhí)行過程如下：

1. 執(zhí)行表達(dá)式1，對循環(huán)變量做初始化；

2. 判斷表達(dá)式2，若其值為真(非0)，則執(zhí)行for循環(huán)體中執(zhí)行代碼塊，然后向下執(zhí)行；若其值為假(0)，則結(jié)束循環(huán);

3. 執(zhí)行表達(dá)式3，(i++)等對于循環(huán)變量進(jìn)行操作的語句;

4. 執(zhí)行for循環(huán)中執(zhí)行代碼塊后執(zhí)行第二步;第一步初始化只會執(zhí)行一次。

5. 循環(huán)結(jié)束，程序繼續(xù)向下執(zhí)行。

注意：for循環(huán)中的兩個分號一定要寫

循環(huán)結(jié)構(gòu)之for循環(huán)(二)

在for循環(huán)中:

• 表達(dá)式1是一個或多個賦值語句，它用來控制變量的初始值；

• 表達(dá)式2是一個關(guān)系表達(dá)式，它決定什么時候退出循環(huán)；

• 表達(dá)式3是循環(huán)變量的步進(jìn)值，定義控制循環(huán)變量每循環(huán)一次后按什么方式變化。

• 這三部分之間用分號 ; 分開。

使用for語句應(yīng)該注意：

1. for循環(huán)中的“表達(dá)式1、2、3”均可不寫為空，但兩個分號(;;)不能缺省。

2. 省略“表達(dá)式1（循環(huán)變量賦初值）”，表示不對循環(huán)變量賦初始值。

3. 省略“表達(dá)式2(循環(huán)條件)”，不做其它處理，循環(huán)一直執(zhí)行（死循環(huán)）。

4. 省略“表達(dá)式3(循環(huán)變量增減量)”，不做其他處理，循環(huán)一直執(zhí)行（死循環(huán)）。

5. 表達(dá)式1可以是設(shè)置循環(huán)變量的初值的賦值表達(dá)式，也可以是其他表達(dá)式。

6. 表達(dá)式1和表達(dá)式3可以是一個簡單表達(dá)式也可以是多個表達(dá)式以逗號分割。

1. 表達(dá)式2一般是關(guān)系表達(dá)式或邏輯表達(dá)式，但也可是數(shù)值表達(dá)式或字符表達(dá)式，只要其值非零，就執(zhí)行循環(huán)體。

2. 各表達(dá)式中的變量一定要在for循環(huán)之前定義。

怎么獲得一個數(shù)的百位，十位和個位

• 百位數(shù)：num/100 可以獲得，因為 int 是整數(shù)型，小數(shù)部分會省略。比如 765/100 的結(jié)果是7

• 十位數(shù)：num%100/10 。比如765%100先得到65，65/10得到6

• 個位數(shù)：num%10。765%10得到5

循環(huán)結(jié)構(gòu)之三種循環(huán)比較

while, do-while 和 for 三種循環(huán)在具體的使用場合上是有區(qū)別的，如下：

在知道循環(huán)次數(shù)的情況下更適合使用for循環(huán);

1. 在不知道循環(huán)次數(shù)的情況下適合使用while或者do-while循環(huán):

• 如果有可能一次都不循環(huán)應(yīng)考慮使用while循環(huán)

• 如果至少循環(huán)一次應(yīng)考慮使用do-while循環(huán)。

但是從本質(zhì)上講，while,do-while和for循環(huán)之間是可以相互轉(zhuǎn)換的。

循環(huán)結(jié)構(gòu)之多重循環(huán)

多重循環(huán)就是在循環(huán)結(jié)構(gòu)的循環(huán)體中又出現(xiàn)循環(huán)結(jié)構(gòu)。

在實際開發(fā)中一般最多用到三層重循環(huán)。

因為循環(huán)層數(shù)越多，運行時間越長，程序越復(fù)雜，所以一般用2-3層多重循環(huán)就可以了。另外不同循環(huán)之間也是可以嵌套的。

多重循環(huán)在執(zhí)行的過程中，外層循環(huán)為父循環(huán)，內(nèi)層循環(huán)為子循環(huán)，

父循環(huán)一次，子循環(huán)需要全部執(zhí)行完，直到跳出循環(huán)。父循環(huán)再進(jìn)入下一次，子循環(huán)繼續(xù)執(zhí)行...

mtianyan: 打印三角形星星堆

#include <stdio.h>
int main(){
    int i, j, k;
    for(i=1; i<5; i++)
    {
        /* 觀察每行的空格數(shù)量，補全循環(huán)條件 */
        for(j=i; j<5; j++)  
        {
            printf(" ");    //輸出空格
        }
        /* 觀察每行*號的數(shù)量，補全循環(huán)條件 */
        for( k=0;k<2*i-1;k++) 
        {
            printf("*");   //每行輸出的*號
        }
        printf("n");     //每次循環(huán)換行
    }
    return 0;
}

使用for循環(huán)打印9×9乘法表

#include <stdio.h>
int main() { 
    // 定義相乘數(shù)字i,j以及結(jié)果result
    int i, j, result;
     for(i=9;i>=1;i--)
     {
        for(j=1;j<=i;j++)
        {
            printf("%d*%d=%d ",i,j,result=i*j);
        }
        printf("n");
     }
    return 0;
}

結(jié)束語句之break語句

那么循環(huán)5次的時候，需要中斷不繼續(xù)訓(xùn)練。在C語言中，可以使用break語句進(jìn)行該操作.

使用break語句時注意以下幾點：

在沒有循環(huán)結(jié)構(gòu)的情況下，break不能用在單獨的if-else語句中。

1. 在多層循環(huán)中，一個break語句只跳出當(dāng)前循環(huán)。

結(jié)束語句之continue語句

那么循環(huán)5次的時候，需要中斷后繼續(xù)訓(xùn)練。在C語言中，可以使用continue語句進(jìn)行該操作

continue語句的作用是結(jié)束本次循環(huán)開始執(zhí)行下一次循環(huán)。

break語句與continue語句的區(qū)別是:

break是跳出當(dāng)前整個循環(huán)，continue是結(jié)束本次循環(huán)開始下一次循環(huán)。

分支結(jié)構(gòu)之switch語句

switch語句結(jié)構(gòu)如下:

mtianyan: switch語句時還應(yīng)注意以下幾點：

1. 在case后的各常量表達(dá)式的值不能相同，否則會出現(xiàn)錯誤。

2. 在case子句后如果沒有break;會一直往后執(zhí)行一直到遇到break;才會跳出switch語句。

3. switch后面的表達(dá)式語句只能是整型或者字符類型。

4. 在case后，允許有多個語句，可以不用{}括起來。

5. 各case和default子句的先后順序可以變動，而不會影響程序執(zhí)行結(jié)果。

6. default子句可以省略不用。

mtianyan: switch與if語句的應(yīng)用(計算是該年的第幾天)

#include <stdio.h>
int main() 
{ 
    /* 定義需要計算的日期 */
    int date = 0;
    int year = 2008;
    int month = 8;
    int day = 8;
    switch(month)
    {
        case 12:date+=30;
        case 11:date+=31;
        case 10:date+=30;
        case 9:date+=31;
        case 8:date+=31;
        case 7:date+=30;
        case 6:date+=31;
        case 5:date+=30;
        case 4:date+=31;
        case 3:
        if((year%4==0&&year%100!=0)||year%400==0)
        {
            date+=29;
        }
        else
        {
            date+=28;
        }
        case 2:
        date+=31;
        case 1:
        date+=day;
        printf("%d年%d月%d日是該年的第%d天",year,month,day,date);
        break;
        default:
        printf("error");
        break;
    }
    return 0;
}

正確: continue只能用在循環(huán)體內(nèi)

臭名遠(yuǎn)揚之goto語句

C語言中也有這樣的語句，就是goto語句，goto語句是一種無條件分支語句.

goto 語句的使用格式為：

goto 語句標(biāo)號;

自創(chuàng)函數(shù)

C語言提供了大量的庫函數(shù): 比如stdio.h提供輸出函數(shù)

自定義函數(shù)的一般形式：

注意：

1. [] 包含的內(nèi)容可以省略，數(shù)據(jù)類型說明省略，默認(rèn)是 int 類型函數(shù); 參數(shù)省略表示該函數(shù)是無參函數(shù)，參數(shù)不省略表示該函數(shù)是有參函數(shù);

2. 函數(shù)名稱遵循標(biāo)識符命名規(guī)范；

3. mtianyan: 自定義函數(shù)盡量放在 main 函數(shù)之前，如果要放在main函數(shù)后面的話, 需要在main函數(shù)之前先聲明自定義函數(shù)，聲明格式為：

[數(shù)據(jù)類型說明] 函數(shù)名稱（[參數(shù)]）;

我們需要用到自定義的函數(shù)的時候，就得調(diào)用它，那么在調(diào)用的時候就稱之為函數(shù)調(diào)用。

在C語言中，函數(shù)調(diào)用的一般形式為：

函數(shù)名（[參數(shù)]）;

注意：

1. 對無參函數(shù)調(diào)用的時候可以將[]包含的省略。

1. []中可以是常數(shù)，變量或其它構(gòu)造類型數(shù)據(jù)及表達(dá)式,多個參數(shù)之間用逗號分隔。

有參與無參

在函數(shù)中不需要函數(shù)參數(shù)的稱之為無參函數(shù)，在函數(shù)中需要函數(shù)參數(shù)的稱之為有參函數(shù)。

有參和無參函數(shù)的一般形式如下：

有參函數(shù)和無參函數(shù)的唯一區(qū)別在于：函數(shù) () 中多了一個參數(shù)列表。

• 有參函數(shù)更為靈活，輸出的內(nèi)容可以隨著n的改變而隨意變動，只要在main函數(shù)中傳遞一個參數(shù)就可以了

• 而在無參函數(shù)中輸出的相對就比較固定，當(dāng)需要改動的時候還需要到自定義的方法內(nèi)改變循環(huán)變量的值。

mtianyan: 形參與實參

函數(shù)的參數(shù)分為形參和實參兩種。

• 形參是在定義函數(shù)名和函數(shù)體的時候使用的參數(shù),目的是用來接收調(diào)用該函數(shù)時傳入的參數(shù)。

就類似小明，說了的話而不實際行動；

• 實參是在調(diào)用時傳遞該函數(shù)的參數(shù)。

就如小剛能實際行動起來。

函數(shù)的形參和實參具有以下特點：

• 形參只有在被調(diào)用時才分配內(nèi)存單元，在調(diào)用結(jié)束時，即刻釋放所分配的內(nèi)存單元。因此，形參只有在函數(shù)內(nèi)部有效。

函數(shù)調(diào)用結(jié)束返回主調(diào)函數(shù)后則不能再使用該形參變量。

• 實參可以是常量、變量、表達(dá)式、函數(shù)等。

無論實參是何種類型的量，在進(jìn)行函數(shù)調(diào)用時，它們都必須具有確定的值，以便把這些值傳送給形參。因此應(yīng)預(yù)先用賦值等辦法使實參獲得確定值。

• 在參數(shù)傳遞時，實參和形參在數(shù)量上，類型上，順序上應(yīng)嚴(yán)格一致，否則會發(fā)生類型不匹配的錯誤。

函數(shù)的返回值

函數(shù)的返回值是指函數(shù)被調(diào)用之后，執(zhí)行函數(shù)體中的程序段所取得的并返回給主調(diào)函數(shù)的值。

函數(shù)的返回值要注意以下幾點：

• 函數(shù)的值只能通過return語句返回主調(diào)函數(shù)。

return語句的一般形式為:

return 表達(dá)式   或者為：return (表達(dá)式);

• 函數(shù)值的類型和函數(shù)定義中函數(shù)的類型應(yīng)保持一致。

notes: 如果兩者不一致，則以函數(shù)返回類型為準(zhǔn)，自動進(jìn)行類型轉(zhuǎn)換。

• 沒有返回值的函數(shù)，返回類型為 void。

注意：

void 函數(shù)中可以有執(zhí)行代碼塊，但是不能有返回值.

mtianyan: void函數(shù)中如果有return語句，該語句只能起到結(jié)束函數(shù)運行的功能。其格式為: return;

遞歸函數(shù)（一）

遞歸就是一個函數(shù)在它的函數(shù)體內(nèi)調(diào)用它自身。

執(zhí)行遞歸函數(shù)將反復(fù)調(diào)用其自身，每調(diào)用一次就進(jìn)入新的一層。

注意遞歸函數(shù)必須有結(jié)束條件

遞歸函數(shù)（二）

5的階乘這個例子進(jìn)行一下剖析，看一看他的運算過程：

程序在計算5的階乘的時候，先執(zhí)行遞推，當(dāng)n=1或者n=0的時候返回1，再回推將計算并返回。由此可以看出遞歸函數(shù)必須有結(jié)束條件。

遞歸函數(shù)特點：

1. 每一級函數(shù)調(diào)用時都有自己的變量，但是函數(shù)代碼并不會得到復(fù)制，如計算5的階乘時每遞推一次變量都不同；

2. 每次調(diào)用都會有一次返回，如計算5的階乘時每遞推一次都返回進(jìn)行下一次；

3. 遞歸函數(shù)中，位于遞歸調(diào)用前的語句和各級被調(diào)用函數(shù)具有相同的執(zhí)行順序；

4. 遞歸函數(shù)中，位于遞歸調(diào)用后的語句的執(zhí)行順序和各個被調(diào)用函數(shù)的順序相反；

5. 遞歸函數(shù)中必須有終止語句。

一句話總結(jié)遞歸：自我調(diào)用且有完成狀態(tài)

任務(wù)
猴子第一天摘下N個桃子，當(dāng)時就吃了一半，還不過癮，就又多吃了一個。第二天又將剩下的桃子吃掉一半，又多吃了一個。以后每天都吃前一天剩下的一半零一個。到第10天在想吃的時候就剩一個桃子了,問第一天共摘下來多少個桃子？并反向打印每天所剩桃子數(shù)。

#include <stdio.h>
int getPeachNumber(int n)  {
    int num;    
    if(n==10)
    {
       return 1;      
    } 
    else
    {
        num = (getPeachNumber(n+1)+1)*2;  
        printf("第%d天所剩桃子%d個n", n, num); 
    }
    return num;
}
int main(){
    int num = getPeachNumber(1);
    printf("猴子第一天摘了:%d個桃子。n", num);
    return 0;
}

遞歸demo

有5個人坐在一起，問第5個人多少歲？他說比第4個人大2歲。問第4個人歲數(shù)，他說比第3個人大2歲。問第3個人，又說比第2人大兩歲。問第2個人，說比第1個人大兩歲。最后 問第1個人，他說是10歲。請問第5個人多大？

程序分析：
利用遞歸的方法，遞歸分為回推和遞推兩個階段。要想知道第5個人歲數(shù)，需知道第4人的歲數(shù)，依次類推，推到第1人（10歲），再往回推。

#include <stdio.h> 
int dfs(int n) {
    return n == 1 ? 10 : dfs(n - 1) + 2;
}
int main() {
    printf("第5個人的年齡是%d歲", dfs(5)); 
    return 0;
} 

局部與全局

C語言中的變量，按作用域范圍可分為兩種，即局部變量和全局變量。

• 局部變量也稱為內(nèi)部變量。局部變量是在函數(shù)內(nèi)作定義說明的。其作用域僅限于函數(shù)內(nèi)， 離開該函數(shù)后再使用這種變量是非法的。在復(fù)合語句中也可定義變量，其作用域只在復(fù)合語句范圍內(nèi)。

• 全局變量也稱為外部變量，它是在函數(shù)外部定義的變量。它不屬于哪一個函數(shù)，它屬于一個源程序文件。其作用域是整個源程序。

變量存儲類別

mtianyan: C語言根據(jù)變量的生存周期來劃分，可以分為靜態(tài)存儲方式和動態(tài)存儲方式。

• 靜態(tài)存儲方式：是指在程序運行期間分配固定的存儲空間的方式。靜態(tài)存儲區(qū)中存放了在整個程序執(zhí)行過程中都存在的變量，如全局變量。

• 動態(tài)存儲方式：是指在程序運行期間根據(jù)需要進(jìn)行動態(tài)的分配存儲空間的方式。動態(tài)存儲區(qū)中存放的變量是根據(jù)程序運行的需要而建立和釋放的，通常包括：函數(shù)形式參數(shù)；自動變量；函數(shù)調(diào)用時的現(xiàn)場保護(hù)和返回地址等。

C語言中存儲類別又分為四類：

• 自動（auto）、

• 靜態(tài)（static）、

• 寄存器的（register）

• 外部的（extern）。

1、用關(guān)鍵字auto定義的變量為自動變量，auto可以省略，auto不寫則隱含定為“自動存儲類別”，屬于動態(tài)存儲方式。如：

2、用static修飾的為靜態(tài)變量，如果定義在函數(shù)內(nèi)部的，稱之為靜態(tài)局部變量；如果定義在函數(shù)外部，稱之為靜態(tài)外部變量。如下為靜態(tài)局部變量：

注意：靜態(tài)局部變量屬于靜態(tài)存儲類別，在靜態(tài)存儲區(qū)內(nèi)分配存儲單元，在程序整個運行期間都不釋放；靜態(tài)局部變量在編譯時賦初值，即只賦初值一次；如果在定義局部變量時不賦初值的話，則對靜態(tài)局部變量來說，編譯時自動賦初值0（對數(shù)值型變量）或空字符（對字符變量）。

mtianyan: 注意：只有局部自動變量和形式參數(shù)可以作為寄存器變量；一個計算機(jī)系統(tǒng)中的寄存器數(shù)目有限，不能定義任意多個寄存器變量；局部靜態(tài)變量不能定義為寄存器變量。

4、用extern聲明的的變量是外部變量，外部變量的意義是某函數(shù)可以調(diào)用在該函數(shù)之后定義的變量。如：

內(nèi)部函數(shù)與外部函數(shù)

• 在C語言中不能被其他源文件調(diào)用的函數(shù)稱謂內(nèi)部函數(shù) ，內(nèi)部函數(shù)由static關(guān)鍵字來定義，因此又被稱謂靜態(tài)函數(shù)，形式為：
  static [數(shù)據(jù)類型] 函數(shù)名（[參數(shù)]）

• 這里的static是對函數(shù)的作用范圍的一個限定，限定該函數(shù)只能在其所處的源文件中使用，因此在不同文件中出現(xiàn)相同的函數(shù)名稱的內(nèi)部函數(shù)是沒有問題的。

• 在C語言中能被其他源文件調(diào)用的函數(shù)稱謂外部函數(shù) ，外部函數(shù)由extern關(guān)鍵字來定義，形式為：
  extern [數(shù)據(jù)類型] 函數(shù)名([參數(shù)])

• C語言規(guī)定，在沒有指定函數(shù)的作用范圍時，系統(tǒng)會默認(rèn)認(rèn)為是外部函數(shù)，因此當(dāng)需要定義外部函數(shù)時extern也可以省略。

靜態(tài)變量只賦值一次

外部函數(shù)練習(xí)

hello.c

#include <stdio.h>
#include "test.c"   //引用test.c文件
extern void printLine()     //這里定義的方法對嗎？{
   printf("**************n");   
}
int main(){
    say();
    return 0;
}

test.c

#include <stdio.h>
void printLine();
static void say(){
printLine();
printf("I love imoocn");
printf("good good study!n");
printf("day day up!n");
printLine();
}

對于hello.c來說，直接引入了test.c文件。那么就可以調(diào)用testc中的static方法say()
而對于test.c并沒有引入，可以通過聲明來調(diào)用另一個源文件中暴露出來的方法。

綜合練習(xí)

北京市出租車打車計費規(guī)則如下：

1. 每公里單價計費2.3元

2. 起步價13元(包含3公里)

3. 晚上23點(含)至次日凌晨5點(不含)打車，每公里單價計費加收20%。

4. 每次乘車加收1元錢的燃油附加稅。
   小明每天上下班都要打車，公司和家的距離為12公里，上午上班時間為9點，下午下班時間為6點。
   請編寫一個小程序計算小明每天打車的總費用。

#include <stdio.h>
float taxifee(int clock,int miles){
    float money;
    if(miles<=3)
    {
        money=14;
        printf("費用為14n");
    }
    else
    {
        if(clock>=23 || clock<5)
        {
            money=13+1+2.3*(miles-3)*1.2;
            printf("夜間車費為：%fn",money);
        }
        else
        {
            money=13+1+2.3*(miles-3);
            printf("日間車費為：%fn",money);
        }
    }
    return money;    
}
int main(){
    printf("打的總費用：%.1fn",taxifee(9,12)+taxifee(18,12));
    return 0;
}

數(shù)組初體驗

程序中也需要容器，只不過該容器有點特殊，它在程序中是一塊連續(xù)的，大小固定并且里面的數(shù)據(jù)類型一致的內(nèi)存空間，它還有個好聽的名字叫數(shù)組?？梢詫?shù)組理解為大小固定，所放物品為同類的一個購物袋，在該購
物袋中的物品是按一定順序放置的。

我們來看一下如何聲明一個數(shù)組：

數(shù)據(jù)類型 數(shù)組名稱[長度];

數(shù)組只聲明也不行啊，看一下數(shù)組是如何初始化的。說到初始化，C語言中的數(shù)組初始化是有三種形式的，分別是：

1. 數(shù)據(jù)類型 數(shù)組名稱[長度n] = {元素1,元素2…元素n};

2. 數(shù)據(jù)類型 數(shù)組名稱[] = {元素1,元素2…元素n};

3. 數(shù)據(jù)類型 數(shù)組名稱[長度n]; 數(shù)組名稱[0] = 元素1; 數(shù)組名稱[1] = 元素2; 數(shù)組名稱[n-1] = 元素n;

我們將數(shù)據(jù)放到數(shù)組中之后又如何獲取數(shù)組中的元素呢？

獲取數(shù)組元素時：數(shù)組名稱[元素所對應(yīng)下標(biāo)];

如：初始化一個數(shù)組 int arr[3] = {1,2,3}; 那么arr[0]就是元素1。

注意：

1. 數(shù)組的下標(biāo)均以0開始；

2. 數(shù)組在初始化的時候，數(shù)組內(nèi)元素的個數(shù)不能大于聲明的數(shù)組長度；

3. mtianyan: 如果采用第一種初始化方式，元素個數(shù)小于數(shù)組的長度時，多余的數(shù)組元素初始化為0；

4. 在聲明數(shù)組后沒有進(jìn)行初始化的時候，靜態(tài)（static）和外部（extern）類型的數(shù)組元素初始化元素為0，自動（auto）類型的數(shù)組的元素初始化值不確定。

數(shù)組的遍歷

數(shù)組就可以采用循環(huán)的方式將每個元素遍歷出來，而不用人為的每次獲取指定某個位置上的元素，例如我們用for循環(huán)遍歷一個數(shù)組：

注意以下幾點：

1. 最好避免出現(xiàn)數(shù)組越界訪問，循環(huán)變量最好不要超出數(shù)組的長度.

2. C語言的數(shù)組長度一經(jīng)聲明，長度就是固定，無法改變，并且C語言并不提供計算數(shù)組長度的方法。

由于C語言是沒有檢查數(shù)組長度改變或者數(shù)組越界的這個機(jī)制，可能會在編輯器中編譯并通過，但是結(jié)果就不能肯定了，因此還是不要越界或者改變數(shù)組的長度

c語言獲取數(shù)組長度

int length = sizeof(arr)/sizeof(arr[0]);

數(shù)組可以由整個數(shù)組當(dāng)作函數(shù)的參數(shù)，也可以由數(shù)組中的某個元素當(dāng)作函數(shù)的參數(shù)：

1. 整個數(shù)組當(dāng)作函數(shù)參數(shù)，即把數(shù)組名稱傳入函數(shù)中，例如：

數(shù)組中的元素當(dāng)作函數(shù)參數(shù)，即把數(shù)組中的參數(shù)傳入函數(shù)中，例如：

數(shù)組作為函數(shù)參數(shù)時注意以下事項：

1. 數(shù)組名作為函數(shù)實參傳遞時，函數(shù)定義處作為接收參數(shù)的數(shù)組類型形參既可以指定長度也可以不指定長度。

2. 數(shù)組元素作為函數(shù)實參傳遞時，數(shù)組元素類型必須與形參數(shù)據(jù)類型一致。

mtianyan: 數(shù)組的應(yīng)用（一）[冒泡排序]

以升序排序為例冒泡排序的思想：相鄰元素兩兩比較，將較大的數(shù)字放在后面，直到將所有數(shù)字全部排序。就像小學(xué)排隊時按大小個排一樣，將一個同學(xué)拉出來和后面的比比，如果高就放后面，一直把隊伍排好。

#include <stdio.h>
int main(){
    double arr[]={1.78, 1.77, 1.82, 1.79, 1.85, 1.75, 1.86, 1.77, 1.81, 1.80};
    int i,j;
    printf("n************排隊前*************n");
    for(i=0;i<10;i++)
    {
        if(i != 9)   
            printf("%1.2f, ", arr[i]);  //%1.2f表示小數(shù)點前一位，小數(shù)點后精確到兩位
        else
            printf("%1.2f", arr[i]);    //%1.2f表示小數(shù)點前一位，小數(shù)點后精確到兩位
    }
    for(i=8; i>=0; i--)
    {
        for(j=0;j<=i;j++)
        {
            if( arr[j]>arr[j+1])      //當(dāng)前面的數(shù)比后面的數(shù)大時
            {
                double temp;    //定義臨時變量temp
                temp=arr[j];//將前面的數(shù)賦值給temp
                arr[j]=arr[j+1];             //前后之?dāng)?shù)顛倒位置
                arr[j+1]=temp;//將較大的數(shù)放在后面    
            }                 
        }                
    }
    printf("n************排隊后*************n");
    for(i=0;i<10;i++)
    {
        if(i != 9)   
            printf("%1.2f, ", arr[i]);  //%1.2f表示小數(shù)點前一位，小數(shù)點后精確到兩位     
        else
            printf("%1.2f", arr[i]);    //%1.2f表示小數(shù)點前一位，小數(shù)點后精確到兩位
    }
    return 0;    
}

數(shù)組的應(yīng)用（二）[數(shù)組查找功能]

當(dāng)我們購物之后，拎著購物袋回到家，會一一檢查購物袋中的物品看是否缺少或者都是想購之物。

那么應(yīng)用到程序中，可以使用數(shù)組查找功能，看看是否存在該數(shù)據(jù)，如果存在并返回該元素的下標(biāo)。

#include <stdio.h>
int getIndex(int arr[5],int value)
{
    int i;
    int index;
    for(i=0;i<5;i++)
    {
       /* 請完善數(shù)組查詢功能 */
       if(arr[i]==value)
        {
            index=i;
            break;
        }  
       index=-1;
    }
    return index;
}
int main()
{
    int arr[5]={3,12,9,8,6};
    int value = 8;
    int index = getIndex(arr,value);      //這里應(yīng)該傳什么參數(shù)呢？
    if(index!=-1)
    {
        printf("%d在數(shù)組中存在，下標(biāo)為：%dn",value,index);             
    }
    else
    {
        printf("%d在數(shù)組中不存在。n",value);    
    }
    return 0;    
}

字符串與數(shù)組

C語言中，是沒有辦法直接定義字符串?dāng)?shù)據(jù)類型的，但是我們可以使用數(shù)組來定義我們所要的字符串。一般有以下兩種格式：

1. char 字符串名稱[長度] = "字符串值";

2. char 字符串名稱[長度] = {'字符1','字符2',...,'字符n','