C順序設計學習筆記（結束）。本站提示廣大學習愛好者：（C順序設計學習筆記（結束））文章只能為提供參考，不一定能成為您想要的結果。以下是C順序設計學習筆記（結束）正文
時間：2015-4-16 09:17
生吞活剝，每有會意，怅然忘食。
學習的進程是苦楚的
第1章 順序設計和C言語
第2章 算法——順序的靈魂
—算法的五個特點
有窮性 確定性 有零個或多個輸出 有一個或多個輸入 無效性
—順序的三種根本構造
順序構造
選擇構造
if 語句
switch 語句
循環構造
while 循環
for 循環
until 循環（就是do ... while循環）
—偽代碼
偽代碼是介於自然言語和計算機言語之間的文字和符號來描繪算法。它好像一篇文章一樣，自上而下地寫上去。
每一行表示一個根本操作。
—構造化順序設計
自頂向下 逐漸細化 模塊化設計 構造化編碼
第3章 最復雜的順序設計——順序順序設計
—數據的表現方式及其運算
常量和變量
常量
整型常量
負數 000 123 0 -18
實型常量
有兩種表示方式
1、十進制小數方式2.5 0.0
2、指數方式 由於在計算機輸出或輸入時，無法表示上角或下角，故規則以字母e或E代表以10為底的指數。
留意：e或E之前必需無數字，且e或E前面必需為負數，不能寫為e5、1e2.5
字符常量
1、普通字符
用單括號括起來的一個字符，例如 ‘a’、‘1’、‘#’
2、本義字符
\' 一個單撇號（‘） 具有此八進制碼的字符
\" 一個雙撇號（“） 輸入此字符
\? 一個問號（?） 輸入此字符
\\ 一個反斜線（\） 輸入此字符
\a 正告 alert 發生聲響或視覺信號
\b 退格 backspace 將以後地位前進一個字符
\f 換頁 form feed 將以後地位移到下一頁的掃尾
\n 換行 line feed 將以後地位移到下一行的掃尾
\r 回車 carriage return 將以後地位移到本行的掃尾（來源於晚期打字機，每打完一行先到行首再換行）
\t 程度制表符 將以後地位移到下一個tab地位
\v 垂直制表符 將以後地位移到下一個垂直目標對齊點
\o、\oo或\ooo 其中一個o代表一個八進制數字
輸入與該八進制碼對應的ASCII字符，例如'\101'的八進制數101的ASCII字符，即'A（八進制數101相當於
十進制數65），'\012'代表八進制數12（即十進制數10）的ASCII碼所對應的字符”換行“符。
\xh[h...] 其中一個h代表一個十六進制數字
輸入與該十六進制碼對應的ASCII字符
字符串常量
符號常量（宏定義）
# definePI 3.1415
符號常量的優點：含義明晰 一改全改
留意：要區分符號常量和變量，不要把符號常量誤以為變量，符號常量不占內存，只是一個暫時符號，在預編譯
之後這個符號就不存在了，故不能對符號常量賦以新值。
變量
變量代表一個有名字的，具有特定屬性的一個存儲單元。它用來寄存數據，也就是寄存變量的值，在順序運轉時期，
它的值是可以改動的。變量名實踐上是以一個名字代表一個存儲地址。
常變量
const int max = 0; 表示max被定義為一個整型變量，在變量存在時期其值不能改動。
改動max的值：const int max = 1;
# include <stdio.h>
int main(void)
{
const int max = 10;
int a = 20;
printf("a = %d\n",a); //輸入a的值為20；
a = max;
printf("a = %d\n",a); //輸入a的值為10.
return 0;
}
—數據類型
所謂類型，就是對數據分配存儲單元的布置，包括存儲單元的長度（所占字節）以及數據的存儲方式。
純量類型：算術類型和指針類型，由於其變量的值是以數字來表示的。
算術類型：其中根本類型（包括浮點型和整型）和枚舉類型變量的值都是數值，統稱為算術類型。
整型類型：
根本整型 int 短整型 short int 長整型 long int 字符型 char
浮點類型：單精度浮點型 float 雙精度浮點型 double
枚舉類型 enum 枚舉類型是順序中用戶定義的證書類型。
指針類型 *
組合類型：數組類型和構造體類型統稱為組合類型。（共用體（結合體）類型不屬於組合類型，由於在同一時間內只要一個成員
具有值。）
數組類型 [ ]
構造體類型 struct
空類型 void
void指針的意義（一切的指針都是4個字節）
C言語規則只要相反類型的指針才可以互相賦值。
void * 指針作為左值用於“接納”恣意類型的指針：
void * p = &p1;
void * 指針作為右值賦值給其他指針時需求強迫類型轉換。
int * p1 = NULL;
char * p2 = ((char *)malloc(sizeof(char) * 20);
由於malloc函數的前往值是void *類型，所以後面需求用 char * 來停止強迫類型轉換。
不存在void類型的變量。
—整型數據
根本整形int
在存儲單元中的存儲方式是：用負數的補碼方式寄存。一個負數的補碼是此數的二進制方式。
正數求補碼：先將此數的相對值寫成二進制方式，然後將一切二進制位取反再+1。
５的原碼 ００００００００｜０００００１０１
按位取反 １１１１１１１１｜１１１１１０１０
再＋１（－５的原碼） １１１１１１１１｜１１１１１０１１
在寄存負數的存儲單元中，最左面一位是用來表示符號的，0為正，1為負。
二進制最大值 01111111 | 11111111 = 十進制 32767
二進制最小值 10000000 | 00000000 = 十進制 -32768
因而，一個兩個字節的整型變量的值的范圍是 -32768~32767
signed int 有符號根本整型
unsigned int 無符號根本整型
由於 unsigned int 二進制無符號位，所以范圍增大一倍。
闡明：1）只要整型（包括字符型）數據可以加 signed 或 unsigned 修飾符，實型數據不能加。
2）對無符號整型數據用”%u“格式輸入，”%u“表示無符號十進制數的格式輸入。
3）在將一個變量定義為無符號整型後，不能賦予一個負值。
—字符型數據
字符與字符代碼
字符是按其代碼（整數）方式存儲的。
各種字符集（包括ASCII字符集）的根本集都包括了127個字符，其中包括：
· 字母：大寫英文字母A~Z，小寫英文字母a~z。
· 數字：0~9。
· 專門符號，29個： ! " # & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ ` { | } ~
· 空格符：空格、程度制表符（tab）、垂直制表符、換行（line feed）、換頁（form feed）。
· 不能顯示的字符：空字符（null，以'\0'表示）、正告（以'\a'表示）、退格（以'\b'表示）、回車（以'\r'表示）等。
可以看到，以上的字符的ASCII代號碼最多用7個二進制位就可以表示。一切127個字符都可以用7個二進制位表示
（ASCII代碼為127時，二進制方式為1111111，7位全都是1）。所以在C中，制定一個字節（8位）存儲一個字符，
此時，字節中的第1地位為0。
字符變量
字符變量，實踐上是一個字節的整型變量，由於它常用來寄存字符，所以成為字符變量，可以把0~127之間的整數賦給一個
字符變量。
# include <stdio.h>
int main (void)
{
char a = 65;
printf("%c\n",a);
return 0;
}
運轉後果： A
press anykey to continue
字符型數據的存儲空間和值的范圍
———————————————————————————————————————
|類型 |字節數|取值范圍 |
———————————————————————————————————————
|signed char 有符號字符型|1|-128~127，即2^7~2^7-1|
———————————————————————————————————————
|unsigned char 無符號字符型|1|0~255，即0~2^8-1 |
———————————————————————————————————————
闡明：在運用有符號字符型變量時，允許存儲的值為-127~127，單字符的代碼不能夠為負值，所以在存儲字符時實踐上只用到
0~127這一局部，其第1位都是0。
假如將一個負整數賦給有符號字符型變量是合法的，但它不代表一個字符，而作為一字節整型變量存儲負整數。
附注：後面已引見，127個根本字符用7個而僅為存儲，假如零碎只提供127個字符，那麼就將char型變量的第一個二進位設為0，
用前面的7位寄存0到127個字符的代碼。在這種狀況下，零碎提供的char類型詳單與 signed char。但是在實踐使用中，
往往覺得127個字符不夠用，希望能多提供一些可用的字符。依據此需求，有的零碎提供了擴展的字符集，把可用的字符由
127個擴展為255個即擴展了一倍。就是把原本不必的第一位用起來，把char變量改為 unsigned char，即第一位並不固定
設為0，而是把8位都用來寄存字符代碼。這樣，可以寄存255個字符代碼，但它並不適用於一切的零碎。
—浮點型數據
浮點型數據是用來表示具有小數點的實數的。
float型 單精度浮點型
float占4個字節，能失掉6位無效數字。
double型 雙精度浮點型
double占8個字節，能失掉15位無效數字。
（在C言語中停止浮點數的算術運算時，將float型數據自動轉換成double型，再停止運算）
long double型 長雙精度浮點型
long double占16個字節，能失掉19位無效數字。
—怎樣確定常量的類型
整型常量
在一個整數的末尾加大寫字母L或小寫字母l，表示它是常整型。
浮點型常量
從編譯零碎把浮點型常量都按雙精度處置，分配8個字節，例如：
float a = 3.14159;
在停止編譯時，對float變量分配4個字節，但關於浮點型常量3.14159，按雙精度處置，分配8個字節。
以上順序會損失精度，但是可以用以下辦法來強迫指定常量的類型：
float a = 3.14159f; //把此3.14159按單精度浮點型常量處置，編譯時不呈現正告。
long double a = 1.23L; //把此1.23作為long double處置
—運算符和表達式
算術運算符
+ - * / %
/ 兩個實數相除的後果是雙精度實數，兩個整數相除的後果是整數，5/3=1，捨去小數局部，
但是假如除數或被除數中有一個為負值，則捨入的方向是不固定的。
% %運算符要求參與運算的對象（即操作數）為整數，後果也是整數。如8%3 = 2。
除 % 以外的運算符的操作數可以是任何算術類型。
自增自減
++i;--i; （在運用i之前，先使i的值+1或-1）
i++;i--; （在運用i之後，再使i的值+1或-1）
留意：自增運算符和自減運算符只能用於變量，而不能用於常量或表達式。
自增運算符常用於循環語句中，使循環變量自動+1；也用於指針變量，使指針指向下一個地址。
算術表達式和運算符的優先級與結合性
自右至左，即右結合性。
不同類型數據間的混合運算
整型、實型、字符型數據之間可以停止混合運算：
1、+ - * / 運算的兩個數中有一個數位float 或 double 型，後果都是double型，由於零碎將一切的float型數據都先轉換為
double 型再停止運算。
2、假如 int 型和float或double型停止運算，先把int型和float型轉換為double型，再停止運算，後果為double型。
3、字符 char型數據與整型數據停止運算，就是把字符的ASCII碼與整型數據停止運算，假如字符型數據與實行數據
停止運算，則將字符的ASCII代碼轉換為double型再停止運算。
一個字符型數據既可以以字符方式輸入，也可以以整數方式（十進制）輸入。
強迫類型轉換運算符
可以應用強迫類型轉換運算符將一個表達式轉換成所需類型。例如：
(double) a （將a轉換成double類型）
(int)(x+y) （將 x+y的值轉換成int型）
(float)(5%3) （將5%3的值轉換成float型）
其普通方式為 （類型名）（表達式）
需求闡明的是，在強迫類型轉換時，失掉一個所需類型的兩頭數據，而原來變量的類型未發作變化。例如：
a = （int）x
假如定義x為float型，a為整型變量，停止強迫類型運算（int）a之後失掉一個int類型的暫時值，它的值等於x 的整數局部，
把它賦給a，留意x的值和類型都未發作變化，仍為float類型，該暫時值在賦值後就不存在了。另外，在函數調用時，有時
為了使實參與形參類型分歧，可以運用強迫類型轉換運算符失掉一個所需類型的參數。
C運算符
（1）算術運算符（+ - * / % ++ --）
（2）關系運算符（> < == >= <= !=）
（3）邏輯運算符（&& || ! ）
（4）位運算符（<< >> ~ | ^ &）
（5）賦值運算符（= 及其擴展賦值運算符）
（6）條件運算符（ ? :）
（7）逗號運算符（ ， ）
（8）指針運算符（ * ）
（9）求字節數運算符 （sizeof）
（10）強迫類型轉換運算符（ （類型） ）
（11）成員運算符 （ . - >）
（12）下標運算符 （ [ ] ）
（13）其他（如函數調用運算符（））
— C 語句
控制語句
1、if（）… else條件語句
2、for（）… 循環語句
3、while（）… 循環語句
4、do…while（） 循環語句
5、continue 完畢本次循環語句
6、break 終止執行switch語句或循環語句
7、switch 多分支選擇語句
8、return 函數前往語句
9、goto 轉向語句，在構造化順序中根本不必goto語句
復合的賦值運算符
+= -=
賦值運算符左側應該是一個可修正的“左值”，左值的意思是他可以呈現在賦值運算符的左側，它的值是可以改動的。
並不是任何方式的數據都可以作為左值，變量可以作為左值，而算術表達式 a+b 就不能作為左值，
常量也不能作為左值，由於常量不能被賦值。能呈現在賦值運算符右側的表達式稱為“右值”，
顯然左值也可以呈現在賦值運算符的右側，因此但凡左值都可以作為右值。
賦值進程中的類型轉換
假如賦值運算符兩側的類型不分歧，但都是算數類型時，在賦值時要停止類型轉換，類型換換是由零碎自動停止的，
轉換的規則是：
1、將浮點型數據（包括單、雙精度）賦給整型變量時，先對浮點數取整，即捨棄小數局部，然後賦予整型變量。
假如 i 為整型變量，執行"i=3.56"的後果是使i的值為3，以整數方式存儲在整型變量中。
2、將整型數據賦給單、雙精度時，數值不變，但以浮點數方式存儲到變量中。假如有float變量，執行“f=23；”。
先將整數23轉換成實數23.0，再按指數方式存儲在變量f中，假如23賦給double型變量 d ，即執行“d = 23；”，
則將整數23轉換成雙精度實數23.0，然後以雙精度浮點數方式存儲到變量d中。
3、將一個double 型數據賦給float變量時，先將雙精度轉換為單精度，即只取6~7位無效數字，存儲到float變量的4個
字節中。應留意雙精度數值的大小不能超出float型變量的數值范圍。
4、字符型數據賦給整型變量時，將字符的ASCII碼賦給整形變量。
5、將一個占字節多的整型數據賦給一個占字節少的整型變量或字符變量時，只將低字節的數據賦值，即發作截斷。
賦值語句和賦值表達式
在if的條件中可以包括賦值表達式，但不能包括賦值語句。
賦值表達式：a = 5
賦值語句：a = 5;
表達式沒有分號，而賦值語句有分號。
變量賦初值
普通變量初始化不是在編譯階段完成的（只要在靜態存儲變量和內部變量的初始化是在編譯階段完成的），而是在順序
運轉時執行本函數時賦予初值的，相當於執行一個賦值語句。
—數據的輸出輸入
C言語自身不提供輸出輸入的語句，輸出和輸入操作是由從規范函數庫中的函數來完成的。
在調用規范輸出輸入庫函數時，文件掃尾應該有以下預處置指令。
# include <stdio.h> //零碎定義函數，是規范方式。
或
# include "stdio.h" //用戶定義函數
用printf函數輸入數據
格式字符
1、%d格式符：輸入一個有符號的十進制整數，若輸入long數據，在d後面加字母l，即%ld。
2、%c格式符：用來輸入一個字符。（ASCII碼中0~127是規范的，128~255是擴展的，由於字符變量無符號）
一個整數，假如在0~127范圍中，也可以用%c輸入，由於字符變量實踐上是一個字節的整型變量。
假如整數較大，則把它的最後一個字節的信息以字符方式輸入。
3、%s格式符：用來輸入一個字符串。
4、%f格式符：用來輸入實數（包括單、雙精度、長雙精度），以小數方式輸入，有以下幾種用法：
①根本型，用%f：
不指定輸入數據的長度，由零碎依據數據的實踐狀況決議數據所占的列數。
零碎處置的辦法普通是：實數中的整數局部全部輸入，小數局部輸入6位。
②制定數據寬度和小數位數，用%m.nf：
m表示數據寬度，n表示小數位數，m包括符號位。
③輸入的數據向左對齊，用%-m.nf：
輸入默許右對齊，- 表示左對齊。
5、%e格式符：用格式聲明%e 指定以指數方式輸入實數。假如不指定輸入數據所占的寬度和數字局部的小數位數，
零碎會自動給出數字局部的小數位數為6位，指數局部占5列（如e+002）。數值按規范化指數方式
輸入（即小數點前必需有而且只要1位非零數字）。例如：
1.234560e+002
其它格式符：
1、i 格式符：作用與d格式符相反。
2、o 格式符：以八進制整數方式輸入。
3、x 格式符：以十六進制數方式輸入。
4、u 格式符：用來輸入無符號（unsigned）型數據，以十進制整數方式輸入。
5、g格式符：用來輸入浮點數，零碎自動選擇 f 格式或許 e 格式輸入，選擇其中長度較短的格式，不輸入有意義的0。
用scanf函數輸出數據
scanf函數所用的格式字符和附加字符用法與printf類似。
運用scanf函數時應留意的問題
1、scanf函數中的“格式控制”前面該當是變量地址，而不是變量名，要運用&運算符。
2、假如在“格式控制字符串”中除了格式聲明以外還有其他字符，則在輸出數據時在對應的地位上應輸出與這些字符
相反的字符。
3、在用“%c ”格式聲明輸出字符時，空格字符和“本義字符”中的字符都作為無效字符輸出，由於%c是字符格式，
所以輸出的每個字符都會被存儲到相應的變量當中。
4、在輸出數值數據時，如輸出空格，回車，tab鍵或遇合法輸出（不屬於數值的字符），則以為該數據完畢。
字符數據的輸出輸入
putchar() 輸入一個字符
putchar函數即可以輸入能在顯示器上顯示的字符，也可以輸入屏幕控制字符，如put('\n')
\\ 整型數據與字符是通用的，可以再putchar（）中輸出該字符的ASCII碼。
getchar() 輸出一個字符
在鍵盤輸出信息時，並不是在鍵盤上敲一個字符，該字符就立刻送到計算機中去的，這些字符先暫存在鍵盤的緩沖
器中，只要按了Enter鍵才把這些字符一同輸出到計算機中，然後按先後順序辨別賦給相應的變量。
執行getchar()可以從輸出設備獲取一個可顯示的字符，也可以獲取一個控制字符。
用getchar()函數失掉的字符可以賦給一個字符變量，也可以作為表達式的一局部putchar(getchar())。
puts() 輸入字符串
gets() 輸出字符串
第4章 選擇構造順序設計
—關系運算符與表達式
運算符優先等級
!（非） > 算術 > 關系 > 邏輯 > 條件 > 賦值
邏輯運算符與表達式
實踐上，邏輯運算符兩側的運算對象不但可以是0和1，或許0和非0的負數，也可以是字符型、浮點型、枚舉型或指針型的
純量數據，零碎最終以0和非0來判別他們屬於真或假。
邏輯型變量（布爾型變量）C言語中沒有bool型變量，C++中有
—條件運算符和條件表達式
（? : ）是三目運算符，要求有三個操作對象，它是C言語中的獨一一個三目運算符。
int a = 1,b = 2,c = 3;
printf("%d",a>b?a:(a<b?c:a)); //輸入後果為3。
—switch語句
switch前面括號內的”表達式“，其值的類型只能是整數類型或許字符型。
第5章 循環構造順序設計
逗號表達式從左向右，賦值表達式從右向左。
在循環構造中定義的變量的無效范圍僅限循環構造中，在循環外不能運用此變量。
break語句只能用於循環語句和switch語句中，而不能獨自運用，假如是雙重循環，在內循環中有break語句，則break僅中止內循環。
第6章 應用數組處置批量數據
—怎樣定義和援用一維數組
假如在被調用的函數（不包括主函數）中定義數組，其長度可以是變量或十分量表達式，如：
void fun(int n)
{
int a [2 * n] // 合法，n的值從實參傳來。
}
在調用fun函數時，形參n從實參失掉值，這種狀況被稱為“可變長數組”，允許每次調用fun函數時，n有不同的值。
但是在執行函數時，n的值是不變的，數組長度是固定的，假如定義數組為靜態存儲方式，則不能用“可變長數組”，如：
static a [2 * n] // 不合法，a數組指定為靜態static存儲方式。
—一維數組的初始化
1、在定義數組時對全部數組元素賦予初值，如：
int a[5] = {1,2,3,4,5};
2、可以只給數組中的一局部元素賦值，如：
int a[5] = {1,2,3};
零碎自動給後兩個元素賦初值為0。
3、假如想使數組中全部元素值為0，可以寫成：
int a[5] = {0};
或
int a[5] = {0,0,0,0,0}
4、在對全部數組元素賦初值時，由於數據的個數已確定，因而可以不指定數組長度，如：
int a[] = {1,2,3,4,5};
闡明：假如在定義數值型數組時，指定了數組的長度並未對之初始化，凡未被初始化列表指定初始化的數據元素，
零碎會自動把它們初始化為0（假如是字符型數組，則初始化為'\0'，假如是指針型數組，則初始化為NULL，即空指針）。
—怎樣定義和援用二維數組
用矩陣方式表示二維數組，是邏輯上的概念，能抽象的表示出行列的關系，而在內存中每個元素是延續寄存的，不是二位的，
而是線性的。
—二維數組的初始化
1、分行給二維數組賦初值，如：
int a[3][4] = {{1,2,3,4}{5,6,7,8}{9,10,11,12}};
2、int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
3、可以對局部元素賦初值，如：
int a[3][4] = {{1},{5},{9}};
它的作用是只對各行第一列（即序號為0的列）的元素賦初值，其他元素自動為0，也可以對各行中的某一元素賦初值，如：
int a[3][4] = {{1},{0,6},{0,0,11}};
初始化後的數組元素如下：
１ ０ ０ ０
０ ６ ０ ０
０ ０ １１ ０
4、假如對全部元素都賦初值（即提供全部數據），則定義數組時對第1維數組的長度可以不指定，但第2維的長度不能省，如：
int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
零碎會依據數據總個數和第2維的長度算出第1維的長度。
—字符串
運用字符串處置函數 # include <string.h>
1、puts()函數——輸入字符串的函數
用puts()函數輸入的字符串中可以包括本義字符。
2、gets()函數——輸出字符串的函數
普通應用gets函數的目的是向字符數組輸出一個字符串，而不關懷其函數值。
留意：用puts和gets函數只能輸入或輸出一個字符串。
3、strcat()函數——字符串銜接函數
其普通方式為：
strcat（字符數組1，字符數組2）
strcat是STRingCATenate（字符串銜接）的縮寫其作用是把兩個字符串銜接起來，把字符串2接到字符串1的前面，後果
放在字符數組1中，函數調用後失掉一個函數值——字符數組1的地址。
闡明：
1、字符數組1必需足夠大，能包容字符數組2.。
2、銜接前兩個字符串前面都有'\0'，銜接時將字符串1前面的'\0'取消，只在新串最後保存'\0'。
4、strcpy()和strncpy()函數——字符串復值函數
其普通方式為
strcpy（字符數組1，字符串2）
strcpy是STRingCoPY的縮寫（字符串復制），它表示將字符串2復制到字符數組1中去。
闡明：
1、字符數組1必需足夠大，能包容字符串2。
2、“字符數組1”必需寫成數組名方式（str1），“字符串2”可以是字符數組名也可以是一個字符串常量。
3、復制時將str2中的字符串和其後的'\0'一同復制到字符數組1中，取代字符數組1中的前n個字符，未復制的不一定是
'\0'，而是str1中原有的內容。
4、不能用賦值語句直接賦值。
5、可以用strncpy函數將字符串2中後面n個字符復制到字符數組1中去，但復制的字符個數不應多於str1中原有的字符，不
包括'\0'。如：
strcpy(str1,str2,5);
5、strcmp()函數——字符串比擬函數
其普通方式為：
strcmp(字符串1，字符串2)
strcmp是STRing CoMPare（字符串比擬）的縮寫。它的作用是比擬字符串1和字符串2。
闡明：
字符串比擬的規則是：將兩個字符串自左向右逐一字符比擬（按ASCII碼值大小比擬），直到呈現不同的字符或'\0'為止。
1、如全部字符相反，則以為兩個字符串相等。
2、若呈現不同的字符，則以第1對不相反的字符的比擬後果為准。
比擬的後果由函數值帶回。
1、假如字符串1 = 字符串2，則函數值為0。
2、假如字符串1 > 字符串2，則函數值為一個正整數。
3、假如字符串1 < 字符串2，則函數值為一個負整數。
留意：對兩個字符串比擬，不能用以下方式：
if (str1 > str2)
printf("yes\n");
而只能用：
if (strcmp(str1 > str2) > 0)
printf("yes\n");
6、strlen()函數——測字符串長度
其普通方式為：
strlen（字符數組）
strlen是STRingLENgth（字符串長度）的縮寫。它是測試字符串長度的函數，函數的值為字符串中的實踐長度（不包括'\0'）
char str[10] = "China";
printf("%d\n",strlen(str)); //或許strlen("China");
輸入：5
7、strlwr()函數——轉換為小寫的函數
8、strupr()函數——轉換為大寫的函數
第7章 用函數完成模塊化順序設計
—調用函數
假如函數值的類型和return語句中表達式的值不分歧，則以函數類型為准。對數值型數據，可以自動停止轉換，即函數類型決
定前往值的類型。
當函數類型被定義為void型時，函數體重不得呈現return語句。
—函數的遞歸調用
在調用一個函數的進程中又呈現直接或直接的調用該函數自身，稱為函數的遞歸調用。如：
int fun(int x)
{
int x,y;
y = fun(x);
return z;
}
在調用函數fun的進程中，又要調用fun函數，這是直接調用本函數。
假如在調用函數f1的進程中要調用f2函數，而在調用f2函數進程中又要調用f1函數，就是直接調用本函數。
舉個例子：有5個學生坐在一同，問第5個學生多少歲，他說比第4個學生大2歲，問第4個學生多少歲，他說比第3個學生大2歲，
問第3個學生多少歲，他說比第2個學生大2歲，問第2個學生，他說比第1個學生大2歲，第一個學生10歲，請問第5
個學生多大？
即：
age(5) = age(4) + 2;
age(4) = age(3) + 2;
age(3) = age(2) + 2;
age(2) = age(1) + 2;
age(1) = 10;
# include <stdio.h>
int main (void)
{
int age(int n);
printf("NO.5,age:%d\n",age(5));
return 0;
}
int age(int n)
{
int c;
if (n == 1)
c = 10;
else
c = age(n-1) + 2;
return c;
}
當最後一次遞歸調用完畢的時分，開端順次出棧，
出棧從最後那次調用開端，直到第一次調用完畢。
用遞歸辦法求 a！。
# include <stdio.h>
int main (void)
{
int jiecheng(int n);
int x;
scanf("%d",&x);
printf("%d\n",jiecheng(x));
return 0;
}
int jiecheng(int a)
{
if (a<0)
printf("data error!\n");
else if (a == 1 || a == 0)
a = 1;
else
a = jiecheng(a-1) * a;
return a;
}
—數組作為函數參數
數組元素可以用作函數實參，不能用作形參，由於形參是在函數被調用時暫時分配的存儲單元，不能夠為一個數組元素獨自
分配存儲單元（數組是一個全體，在內存中占延續的一段存儲空間）。在用數組元素做函數實參時，把實參的值傳給形參，
是“值傳遞”的方式。數據傳遞的方向是從實參傳到形參，單向傳遞。
出了用數組元素作為函數參數外，還可以用數組名作為函數參數（包括實參和形參），該當留意的是：用數組元素作實參時，
向形參變量（數組名或指針變量）傳遞的是數組首元素的地址。
—部分變量和全局變量
定義變量有三種狀況：
1、在函數的掃尾定義。
2、在函數內的復合語句定義。
3、在函數的內部定義。
部分變量
在一個函數外部定義的變量只在本函數范圍內無效，也就是說只要在本函數內才干援用它們，在此函數不測是不能運用這些
變量的。在復合語句內定義的變量只在本復合語句范圍內無效，在該復合語句以外是不能運用這些變量的，以上這些稱為“部分
變量”。
全局變量
在函數內定義的變量是部分變量，而在函數外定義的變量稱為內部變量，內部變量是全局變量（也稱全程變量）。全局變量可以
為本文件中其他函數所共用。它的無效范圍為從定義變量的地位開端到根源文件完畢。
留意：在函數內定義的變量是部分變量，在函數外定義的變量是全局變量。
為了便與區別全局變量和部分變量，在C順序設計人員中有一個習氣（但非規則），將全局變量名的第一個字母用大寫表示。
當部分變量和全局變量抵觸時，部分變量無效，全局變量被屏蔽。
從作用域看：
全局變量具有全局作用域。全局變量只需在一個源文件中定義，就可以作用於一切的源文件。當然，其他不包括全局變量定義的
源文件需求用extern關鍵字再次聲明這個全局變量。
—變量的存儲方式和生活期
靜態存儲方式與靜態存儲方式
從變量的作用域的角度來察看，變量可以分為全局變量和部分變量。
還可以從另一個角度，即從變量值存在的時間（即生活期）來察看。有的變量在順序運轉的整個進程都是存在的，而有的變量則
是在調用其所在的函數是才暫時分配存儲單元，而在函數調用完畢後該存儲單元馬上就釋放了，變量不存在了。也就是說，變量
的存儲有兩種不同的方式：靜態存儲方式和靜態存儲方式。靜態存儲方式是指在順序運轉時期由零碎分配固定的存儲空間的方式，
而靜態存儲方式則是在順序運轉時期依據需求停止靜態的分配存儲空間的方式。
先看一下內存中的供用戶運用的存儲空間的狀況。這個存儲空間可以分為3個局部：
1、順序區。
2、靜態存儲區。
3、靜態存儲區。
數據辨別寄存在靜態存儲區和靜態存儲區中。全局變量全部寄存在靜態存儲區中，在開端執行時給全局變量分配存儲區，順序執行
終了就釋放。在順序執行進程中它們占據固定的存儲單元，而不是靜態的停止分配和釋放。
在靜態存儲區中寄存以下數據：
1、函數方式參數。在調用函數時給形參分配存儲空間。
2、函數定義的沒有用的關鍵字static聲明的變量，即自動變量。
3、函數調用時的現場維護和前往地址等。
對以上這些數據，在函數調用開端時分配靜態存儲空間，函數完畢時釋放這些空間。在順序執行進程中，這種分配和釋放是靜態的，
假如在一個順序中兩次調用同一函數，而在此函數中定義了部分變量。在兩次調用時分配給這些部分變量的存儲空間的地址能夠是
不相反的。
在C言語中，每一個變量和函數都有兩個屬性：數據類型和數據的存儲類別。存儲類別指的是數據在內存中存儲的方式（如靜態存
儲和靜態存儲）。C言語的存儲類別包括4種：自動的 auto（零碎默許類別）、靜態的 statis、存放器的 register、內部的 extern。
自動變量 （auto自動變量）：
函數中的部分變量，假如不專門聲明為 static 靜態存儲類別，都是靜態地分配存儲空間的，數據存儲在靜態存儲區中。函數中
的形參和在函數中定義的部分變量（包括在復合語句中定義的部分變量），都屬於此類。在調用該函數時，零碎會給這些變量
分配存儲空間，在函數調用完畢時就自動釋放這些存儲空間。因而這類部分變量稱為自動變量。自動變量用關鍵字 auto作為
存儲類別的聲明。實踐上，關鍵字 auto可以省略，不寫auto 則隱含指為“自動存儲類別”，它屬於靜態存儲方式。順序中大多
數變量都屬於自動變量。
靜態部分變量（static部分變量）
有時希望函數中的部分變量的值在函數調用完畢後不消逝而持續保存原值，即其占用的存儲單元不釋放，在下一次再調用該
函數時，該變量已有值（就是上一次函數調用完畢時的值）。這是就應該指定該部分變量為“靜態部分變量”，用關鍵字 static
停止聲明。
存放器變量（register 變量）
普通狀況下，變量（包括靜態存儲方式和靜態存儲方式）的值是寄存在內存中的。當順序中用到哪一個變量的值時，由控制器
收回指令將內存中該變量的值送到運算器中。經過運算器停止運算，假如需求存數，再從運算器將該數據送到內存中。
假如有一些變量運用頻繁（例如在一個函數中執行10000次循環，每次循環中都要援用某部分變量），則為存取變量的值要花
費不少時間。為進步執行效率，允許將部分變量的值放在CPU中的存放器中，需求時直接從存放器中取出參與運算，不用再
到內存中去存取，。由於對存放器的存取速度遠高於對內存的存取速度，因而這樣做可以進步執行效率。這種變量叫做存放
器變量。用關鍵字register 作聲明即可。如：
register int f； //定義f為存放器變量。
由於如今的計算機的速度越來越快，功能越來越高，優化的編譯零碎可以辨認運用頻繁的變量，從而自動的將這些變量寄存
在存放器中，而不需求順序設計者去指定。因而，如今實踐上用register 聲明變量的必要性不大，只需了理解即可。
全局變量（extern變量）
全局變量都是寄存在靜態存儲區中的，因而它們的生活期是固定的，存在於順序的整個運轉進程。普通來說，內部變量是在
函數的內部定義的全局變量，它的作用域是從變量的定義處開端，到本順序文件的末尾。在此作用域內，全局變量可以為程
序中各個函數所援用。但有時順序設計人員希望能擴展內部變量的作用域，有以下幾種狀況：
1、在一個文件內擴展內部變量的作用域。
假如內部變量不在文件的掃尾定義，其無效的作用范圍只限於定義處到文件的完畢。在定義點之前的函數不能援用該外
部變量。假如在定義點之前的函數需求援用該內部變量，則應該在飲用之前用關鍵字extern對該變量做“內部變量聲
明”，表示把該內部變量的作用於擴展到此地位，有了此聲明，就可以從聲明處起，合法的運用該內部變量。
用extern 聲明內部變量時，類型名可以寫也可以省寫。例如“extern int A,B,C;”也可以寫成“extern A,B,C;”.由於它不
是定義變量，只需寫出內部變量名即可。
2、將內部變量的作用域擴展到其他文件
在恣意一個文件中定義內部變量A，而在靈異文件中用 extern 對A作“內部變量聲明”，即“extern A;”
當文件和函數都有該變量時，extern的處置方式為：先找函數，再找文件，找不到按出錯處置。
3、將內部變量的作用域限制在本文件中
有時在順序設計中希望某些內部變量只限於被本文件援用，而不能被其他文件援用，可以在定義內部變量時加一個
static 聲明。例如：
file1.c file2.c
static int A; extern A;
A = A * 2; //出錯
這種加上static聲明、只能用於本文件的內部變量稱為“靜態內部變量”。
用static 聲明一個變量的作用是：
1、對部分變量用static聲明，把它分配在靜態存儲區，該變量在整個順序執行時期不釋放，其所分配的空間一直存在。
2、對全局變量用static聲明，則該變量的作用於只限於本文件模塊
留意：
用auto、register、static聲明變量時，是在定義變量的根底上加上這些關鍵字，而不能獨自運用，編譯時會被以為“重新
定義”。
存儲類別小結
對一個數據的定義，需求指定兩種屬性：數據類型和存儲類別，辨別運用兩個關鍵字：
static int a; //靜態部分整型變量或靜態內部整型變量
auto char c; //自動變量，在函數內定義（自動變量是自動創立自動釋放，存在於棧；靜態變量需求請求內存 malloc）
register int b; //存放器變量，在函數內定義
此外，可以用extern聲明已定義的內部變量：
extern b //將已定義的內部變量b的作用域擴展至此
上面從不同角度做歸結：
1、從作用域角度區分，有部分變量和全局變量。它們采用的存儲類別如下：
按作用域角度區分：
（1）部分變量：自動變量，即靜態部分變量（分開函數，值就消逝）。
靜態部分變量（分開函數，值仍保存）。
存放器變量（分開函數，值就消逝）。
（方式參數可以定義為自動變量或存放器變量）
（2）全局變量：靜態內部變量（只限本文件援用）。
內部變量（即非靜態的內部變量，允許其他文件援用）。
2、從變量存在的時間（生活期）來區分，有靜態存儲和靜態存儲兩品種型。靜態存儲是順序整個運轉時間都存在，而靜態
存儲則是在調用函數時暫時分配單元。
按變量的生活期區分：
（1）靜態存儲：自動變量（本函數無效）。
存放器變量（本函數內無效）。
方式參數（本函數內無效）。
（2）靜態存儲：靜態部分變量（函數內無效）。
靜態內部變量（本文件內無效）。
內部變量（用extern聲明後，其他文件可援用）。
3、從變量值寄存的地位來區分：
（1）內存中靜態存儲區：靜態部分變量
靜態內部變量（函數內部靜態變量）。
內部變量（可為其他文件援用）。
（2）內存中靜態存儲區：自動變量和方式參數。
（3）cpu中的存放器：存放器變量。
4、關於作用域和生活期的概念。
假如一個變量在某個文件或函數范圍內是無效的，就稱該范圍為該變量的作用域，在此作用域內可以援用該變量，在專
業書中稱變量在此作用域內“可見”。假如一個變量值在某一時辰是存在的，則以為這一時辰屬於該變量的生活期，或稱
該變量在此時辰“存在”。
———————————————————————————————————
| | 函數內 | 函數外 |
| 變量存儲類別 ——————————————————————
| | 作用域 | 存在性| 作用域 | 存在性 |
———————————————————————————————————
| 自動變量和存放器變量| √ | √ | × | × |
———————————————————————————————————
| 靜態部分變量 | √ | √ | × | × |
———————————————————————————————————
| 靜態內部變量 | √ | √ |√只限本文件| √ |
———————————————————————————————————
| 內部變量 | √ | √ | √ | √ |
———————————————————————————————————
5、static對部分變量和全局變量的作用不同，對部分變量來說，它使變量由靜態存儲方式改動為靜態存儲方式。而對全局
變量來說，它使變量部分化（局限於本文件），但仍為靜態存儲方式，從作用域角度來看，凡有static聲明的，其作用
都是局限的，或許是局限於本函數內（靜態部分變量）。或許局限於本文件內（靜態內部變量）。
第8章 擅長應用指針
假如p的初值為&a[0]，則p+i和a+i就是數組元素a[i]的地址，或許說，它們指向a數組序號為i的元素。[ ]實踐上是變址運算符，即
將a[i]按a+i計算地址，然後找出此地址單元中的值（先找到a地址，然後再找a+i的地址）。
————指向多維數組的指針
————指針數組
————多級指針
————指針數組做main函數的形參 ————這幾個了解的不透徹，就不寫了
—經過指針援用字符串
# include <stdio.h>
int main (void)
{
char * string \ " I love China!";
printf("%s\n",string);
return 0;
}
運轉：
I love China!
留意：string被定義為一個指針變量，基類型為字符型。請留意它只能指向一個字符類型數據，而不能同時指向多個字符數據，
更不是把“I love China!”這些字符寄存到string中（指針變量只能寄存地址），也不是把字符串賦給*string。只是把字符串
的第一個字符的地址賦給了指針變量*string。
—運用字符指針變量和字符數組的比擬
1、字符數組由若干個元素組成，每個元素中放一個字符，而字符指針變量中寄存的是地址（字符串第一個字符的地址），絕不是
將字符串放到字符指針變量中。
2、賦值方式。可以對字符指針變量賦值，但不能對數組名賦值。
3、存儲單元的內容，編譯時為字符數組分配若干存儲單元，以寄存個元素的值，而對字符指針變量，只分配了一個存儲單元。
4、指針變量的值是可以改動的，而數組名代表一個固定的值，不能改動。
—靜態內存分配與指向它的指針變量
什麼是內存的靜態分配
全局變量是分配在內存中的靜態存儲區的，飛靜態的部分變量（包括形參）是分配在內存中的靜態存儲區的，這個存儲區是一個
稱之為——棧——的區域，為變量分配存儲空間。
除此之外，C言語還允許樹立內存靜態分配區域，以寄存一些暫時用的數據，這些數據不用在順序的聲明局部定義，也不用等到
函數完畢時才釋放，而是需求時隨時開拓，不需求時隨時釋放，這些數據是暫時寄存在一個特別的自在存儲區稱為——堆——區
域，可以依據需求，向零碎請求所需大小的空間（malloc函數）。由於未在聲明局部定義它們為變量或數組，因而不能經過變量
名或數組名去援用這些數據，只能經過指針來援用，malloc函數的定義：
int *p；
*p = （int*）malloc（sizeof（int））；
怎樣樹立內存的靜態分配
對內存的靜態分配是經過零碎提供的庫函數來完成的，次要有malloc，calloc，free，realloc這四個函數。
1、運用 malloc 函數
其函數原型為：
(void *) malloc(unsigned int size)
其作用是在內存的靜態存儲區中分配一個長度為size的延續空間。形參size的類型為無符號整型（不允許為正數）。此函數的值
（即前往值）是所分配區域的第一個字節的地址，或許說，此函數是一個指針型函數，前往的指針只想該分配區域的掃尾地位
2、運用 free 函數
其函數原型為
void free(void *p);
其作用是釋放指針變量p所指向的靜態空間，使這局部空間能重新被其他變量運用。
第9章 用戶自己樹立數據類型
—定義構造體的方式
1、 定義構造體數組
struct student//struct student 是用戶自定義的一種數據類型
{
int age；
float score；
}
struct student s1 = {19,92.5} ；
2、
struct student
{
int age；
float score；
} s1；//只能定義一次
—怎樣運用構造體變量
1、賦值和初始化
定義的同時可以全體賦初值
假如定義完之後，只能單個的賦初值。
struct student//struct student 是用戶自定義的一種數據類型
{
int age；
float score；
}
struct student s1 = {19,92.5} ；//定義的同時賦初值
struct student s2；//定義
s2.age = 10；//分開賦值
s2.score = 80.5；
printf("%d %f\n",s1.age,s1.score);
printf("%d %f\n",s2.age,s2.score);
—構造體指針
所謂構造體質針就是指向構造體變量的指針，一個構造體變量的起始地址就是這個構造體變量的指針。假如把一個構造體變量的起
始地址寄存在一個指針變量中，那麼這個指針變量就指向該構造體變量。
指向構造體變量的指針：
指向構造體對象的指針變量既可指向構造體變量，也可指向構造體數組中的元素。指針變量的基類型必需與構造體變量的類型
相反。例如：
struct student * p; // p可以指向struct student類型的變量或數組元素
# include <stdio.h>
# include <string.h>
struct student
{
int age;
char name[10];
};
int main (void)
{
struct student s1;
struct student *s2;
s2 = &s1; // s2 指向 s1，必需加&取地址符號
s1.age = 18;
strcpy(s1.name,"wang");
printf("%d %s\n",s1.age,s1.name);
printf("%d %s\n",(*s2).age,(*s2).name);
return 0;
}
闡明：為了方便和直觀，C言語允許把(*p).name用p->num來替代，“->”代表一個箭頭，p->num表示p所指向的構造體變量中的num
成員。"->"稱為指向運算符。
假如p指向一個構造體變量s1，以下三種辦法等價：
1、s1. 成員名
2、（*p）. 成員名
3、p -> 成員名
—用指針處置鏈表 ——見數據構造
鏈表有一個“頭指針”變量，它寄存一個地址，該地址指向一個元素。鏈表中每一個元素稱為“結點”，每個結點都應包括兩個局部：
（1）用戶需求用的實踐數據；（2）下一個結點的地址。可以看出，頭指針指向第1個元素，第1個元素又指向第2個元素……直到
最後一個元素，該元素不再指向其他元素，它稱為“表尾”，它的地址局部寄存一個“NULL”（表示空地址），鏈表到此完畢。
