C語言基本教程 第5課:語句和表達式

C語言雖然沒有限制 if else 能夠處理的分支數量，但當分支過多時，用 if else 處理會不太方便，而且容易出現 if else 配對出錯的情況。例如，輸入一個整數，輸出該整數對應的星期幾的英文表示：

1. #include
2. int main(){
3. int a;
4. printf("Input integer number:");
5. scanf("%d",&a);
6. if(a==1){
7. printf("Monday\n");
8. }else if(a==2){
9. printf("Tuesday\n");
10. }else if(a==3){
11. printf("Wednesday\n");
12. }else if(a==4){
13. printf("Thursday\n");
14. }else if(a==5){
15. printf("Friday\n");
16. }else if(a==6){
17. printf("Saturday\n");
18. }else if(a==7){
19. printf("Sunday\n");
20. }else{
21. printf("error\n");
22. }
23. return 0;
24. }

1. #include
2. int main(){
3. int a;
4. printf("Input integer number:");
5. scanf("%d",&a);
6. switch(a){
7. case 1: printf("Monday\n"); break;
8. case 2: printf("Tuesday\n"); break;
9. case 3: printf("Wednesday\n"); break;
10. case 4: printf("Thursday\n"); break;
11. case 5: printf("Friday\n"); break;
12. case 6: printf("Saturday\n"); break;
13. case 7: printf("Sunday\n"); break;
14. default:printf("error\n"); break;
15. }
16. return 0;
17. }

switch(表達式){
case 整型數值1: 語句 1;
case 整型數值2: 語句 2;
......
case 整型數值n: 語句 n;
default: 語句 n+1;
}

1. #include
2. int main(){
3. int a;
4. printf("Input integer number:");
5. scanf("%d",&a);
6. switch(a){
7. case 1: printf("Monday\n");
8. case 2: printf("Tuesday\n");
9. case 3: printf("Wednesday\n");
10. case 4: printf("Thursday\n");
11. case 5: printf("Friday\n");
12. case 6: printf("Saturday\n");
13. case 7: printf("Sunday\n");
14. default:printf("error\n");
15. }
16. return 0;
17. }

1. #include
2. int main(){
3. int a;
4. printf("Input integer number:");
5. scanf("%d",&a);
6. switch(a){
7. case 1: printf("Monday\n"); break;
8. case 2: printf("Tuesday\n"); break;
9. case 3: printf("Wednesday\n"); break;
10. case 4: printf("Thursday\n"); break;
11. case 5: printf("Friday\n"); break;
12. case 6: printf("Saturday\n"); break;
13. case 7: printf("Sunday\n"); break;
14. default:printf("error\n"); break;
15. }
16. return 0;
17. }

1. case 10: printf("..."); break; //正確
2. case 8+9: printf("..."); break; //正確
3. case 'A': printf("..."); break; //正確，字符和整數可以相互轉換
4. case 'A'+19: printf("..."); break; //正確，字符和整數可以相互轉換
5. case 9.5: printf("..."); break; //錯誤，不能為小數
6. case a: printf("..."); break; //錯誤，不能包含變量
7. case a+10: printf("..."); break; //錯誤，不能包含變量

在上邊例子中，if 的判斷條件中使用了<=、>、!=等符號，它們專門用在判斷條件中，讓程序決定下一步的操作，稱為關系運算符（Relational Operators）。

關系運算符在使用時，它的的兩邊都會有一個表達式，比如變量、數值、加減乘除運算等，關系運算符的作用就是判明這兩個表達式的大小關系。注意，是判明大小關系，不是其他關系。

C語言提供了以下關系運算符：

&&是一個新的運算符，稱為邏輯運算符，表示age>=18和score>=60兩個條件必須同時成立才能執行 if 後面的代碼，否則就執行 else 後面的代碼。

在高中數學中，我們就學過邏輯運算，例如p為真命題，q為假命題，那麼“p且q”為假，“p或q”為真，“非q”為真。在C語言中，也有類似的邏輯運算：

邏輯運算的結果

1) 與運算(&&)

5&&0

(5>0) && (4>2)

2) 或運算(||)

10 || 0

(5>0) || (5>8)

3) 非運算(!)

!0

!(5>0)

邏輯運算符和其它運算符優先級從低到高依次為：

賦值運算符(=) < &&和|| < 關系運算符 < 算術運算符 < 非(!)

1. #include
2. int main(){
3. char c='k';
4. int i=1, j=2, k=3;
5. float x=3e+5, y=0.85;
6. int result_1 = 'a'+5 printf( "%d, %d\n", result_1, -i-2*j>=k+1 );
7. printf( "%d, %d\n", 1 printf( "%d, %d\n", i+j+k==-2*j, k==j==i+5 );
8. return 0;
9. }

a>b && c>d 等價於 (a>b)&&(c>d)!b==c||dc&&x+yc)&&((x+y) 另外，邏輯表達式也可以嵌套使用，例如a>b && b || 9>c，a || c>d && !p

 

循環結構

所謂循環（Loop），就是重復地執行同一段代碼，例如要計算 1+2+3+……+99+100 的值，就要重復進行99次加法運算。

while循環

while循環的一般形式為：

 

while(表達式){
語句塊
}

意思是，先計算“表達式”的值，當值為真（非0）時， 執行“語句塊”；執行完“語句塊”，再次計算表達式的值，如果為真，繼續執行“語句塊”……這個過程會一直重復，直到表達式的值為假（0），就退出循環，執行 while 後面的代碼。

我們通常將“表達式”稱為循環條件，把“語句塊”稱為循環體，整個循環的過程就是不停判斷循環條件、並執行循環體代碼的過程。

用 while 循環計算1加到100的值：

1. #include
2. int main(){
3. int i=1, sum=0;
4. while(i<=100){
5. sum+=i;
6. i++;
7. }
8. printf("%d\n",sum);
9. return 0;
10. }

運行結果：
5050

代碼分析：
1) 程序運行到 while 時，因為 i=1，i<=100 成立，所以會執行循環體；執行結束後 i 的值變為 2，sum 的值變為 1。

2) 接下來會繼續判斷 i<=100是否成立，因為此時 i=2，i<=100 成立，所以繼續執行循環體；執行結束後 i 的值變為 3，sum 的值變為3。

3) 重復執行步驟 2)。

4) 當循環進行到第100次，i 的值變為 101，sum 的值變為5050；因為此時 i<=100 不再成立，所以就退出循環，不再執行循環體，轉而執行while循環後面的代碼。

while 循環的整體思路是這樣的：設置一個帶有變量的循環條件，也即一個帶有變量的表達式；在循環體中額外添加一條語句，讓它能夠改變循環條件中變量的值。這樣，隨著循環的不斷執行，循環條件中變量的值也會不斷變化，終有一個時刻，循環條件不再成立，整個循環就結束了。

如果循環條件中不包含變量，會發生什麼情況呢？

1) 循環條件成立時的話，while 循環會一直執行下去，永不結束，成為“死循環”。例如：

1. #include
2. int main(){
3. while(1){
4. printf("1");
5. }
6. return 0;
7. }

運行程序，會不停地輸出“1”，直到用戶強制關閉。

2) 循環條件不成立的話，while 循環就一次也不會執行。例如：

1. #include
2. int main(){
3. while(0){
4. printf("1");
5. }
6. return 0;
7. }

運行程序，什麼也不會輸出。

再看一個例子，統計從鍵盤輸入的一行字符的個數：

1. #include
2. int main(){
3. int n=0;
4. printf("Input a string:");
5. while(getchar()!='\n') n++;
6. printf("Number of characters: %d\n", n);
7. return 0;
8. }

運行結果：
Input a string:c.biancheng.net↙
Number of characters: 15

本例程序中的循環條件為getchar()!='\n'，其意義是，只要從鍵盤輸入的字符不是回車就繼續循環。循環體n++;完成對輸入字符個數計數。

do-while循環

除了while循環，在C語言中還有一種 do-while 循環。

do-while循環的一般形式為：

do{
語句塊
}while(表達式);

do-while循環與while循環的不同在於：它會先執行“語句塊”，然後再判斷表達式是否為真，如果為真則繼續循環；如果為假，則終止循環。因此，do-while 循環至少要執行一次“語句塊”。

用do-while計算1加到100的值：

1. #include
2. int main(){
3. int i=1, sum=0;
4. do{
5. sum+=i;
6. i++;
7. }while(i<=100);
8. printf("%d\n", sum);
9. return 0;
10. }

運行結果：
5050

注意while(i<=100);最後的分號;，這個必須要有。

while循環和do-while各有特點，大家可以適當選擇，實際編程中使用while循環較多。

除了while循環，C語言中還有for循環，它的使用更加靈活，完全可以取代 while 循環。

上節我們使用 while 循環來計算1加到100的值，代碼如下：

1. #include
2. int main(){
3. int i, sum=0;
4. i = 1; //語句①
5. while(i<=100 /*語句②*/ ){
6. sum+=i;
7. i++; //語句③
8. }
9. printf("%d\n",sum);
10. return 0;
11. }

可以看到，語句①②③被放到了不同的地方，代碼結構較為松散。為了讓程序更加緊湊，可以使用 for 循環來代替，如下所示：

1. #include
2. int main(){
3. int i, sum=0;
4. for(i=1/*語句①*/; i<=100/*語句②*/; i++/*語句③*/){
5. sum+=i;
6. }
7. printf("%d\n",sum);
8. return 0;
9. }

在 for 循環中，語句①②③被集中到了一起，代碼結構一目了然。

for 循環的一般形式為：

 

for(表達式1; 表達式2; 表達式3){
語句塊
}

它的運行過程為：
1) 先執行“表達式1”。
2) 再執行“表達式2”，如果它的值為真（非0），則執行循環體，否則結束循環。
3) 執行完循環體後再執行“表達式3”。
4) 重復執行步驟 2) 和 3)，直到“表達式2”的值為假，就結束循環。

上面的步驟中，2) 和 3) 是循環條件，會重復判斷

“表達式1”僅在第一次循環時執行，以後都不會再執行，可以認為這是一個初始化語句。“表達式2”一般是一個關系表達式，決定了是否還要繼續下次循環，稱為“循環條件”。“表達式3”很多情況下是一個帶有自增或自減操作的表達式，以使循環條件逐漸變得“不成立”。

for循環的執行過程可用下圖表示：


我們再來分析一下“計算從1加到100的和”的代碼：

1. #include
2. int main(){
3. int i, sum=0;
4. for(i=1; i<=100; i++){
5. sum+=i;
6. }
7. printf("%d\n",sum);
8. return 0;
9. }

運行結果：
5050

代碼分析：
1) 執行到 for 語句時，先給 i 賦初值1，判斷 i<=100 是否成立；因為此時 i=1，i<=100 成立，所以執行循環體。循環體執行結束後（sum的值為1），再計算 i++。

2) 第二次循環時，i 的值為2，i<=100 成立，繼續執行循環體。循環體執行結束後（sum的值為3），再計算 i++。

3) 重復執行步驟 2)，直到第101次循環，此時 i 的值為101，i<=100 不成立，所以結束循環。

由此我們可以總結出for循環的一般形式：

for(初始化語句; 循環條件; 自增或自減){
語句塊
}

for 循環中的三個表達式

for 循環中的“表達式1（初始化條件）”、“表達式2(循環條件)”和“表達式3（自增或自減）”都是可選項，都可以省略（但分號;必須保留）。

1) 修改“從1加到100的和”的代碼，省略“表達式1（初始化條件）”：

1. int main(){
2. int i = 1, sum = 0;
3. for( ; i<=100; i++){
4. sum+=i;
5. }

可以看到，將i=1移到了 for 循環的外面。

2) 省略了“表達式2(循環條件)”，如果不做其它處理就會成為死循環。例如：

1. for(i=1; ; i++) sum=sum+i;

相當於：

1. i=1;
2. while(1){
3. sum=sum+i;
4. i++;
5. }

所謂死循環，就是循環條件永遠成立，循環會一直進行下去，永不結束。死循環對程序的危害很大，一定要避免。

3) 省略了“表達式3(自增或自減)”，就不會修改“表達式2(循環條件)”中的變量，這時可在循環體中加入修改變量的語句。例如：

1. for( i=1; i<=100; ){
2. sum=sum+i;
3. i++;
4. }

4) 省略了“表達式1(初始化語句)”和“表達式3(自增或自減)”。例如：

1. for( ; i<=100 ; ){
2. sum=sum+i;
3. i++;
4. }

相當於：

1. while(i<=100){
2. sum=sum+i;
3. i++;
4. }

5) 3個表達式可以同時省略。例如：

for( ; ; ) 語句

相當於：

while(1) 語句

6) “表達式1”可以是初始化語句，也可以是其他語句。例如：

1. for( sum=0; i<=100; i++ ) sum=sum+i;

7) “表達式1”和“表達式3”可以是一個簡單表達式也可以是逗號表達式。

1. for( sum=0,i=1; i<=100; i++ ) sum=sum+i;

或：

1. for( i=0,j=100; i<=100; i++,j-- ) k=i+j;

8) “表達式2”一般是關系表達式或邏輯表達式，但也可是數值或字符，只要其值非零，就執行循環體。例如：

1. for( i=0; (c=getchar())!='\n'; i+=c );

又如：

1. for( ; (c=getchar())!='\n' ; )
2. printf("%c",c);

使用while或for循環時，如果想提前結束循環（在不滿足結束條件的情況下結束循環），可以使用break或continue關鍵字。

break關鍵字

當 break 關鍵字用於 while、for 循環時，會終止循環而執行整個循環語句後面的代碼。

使用 while 循環計算1加到100的值：

1. #include
2. int main(){
3. int i=1, sum=0;
4. while(1){ //循環條件為死循環
5. sum+=i;
6. i++;
7. if(i>100) break;
8. }
9. printf("%d\n", sum);
10. return 0;
11. }

運行結果：
5050

while 循環條件為 1，是一個死循環。當執行到第100次循環的時候，計算完i++;後 i 的值為 101，此時 if 語句的條件 i> 100 成立，執行break;語句，結束循環。

在多層循環中，一個 break 語句只向外跳一層。例如，輸出一個4*4的整數矩陣：

1. #include
2. int main(){
3. int i=1, j;
4. while(1){ // 外層循環
5. j=1;
6. while(1){ // 內層循環
7. printf("%-4d", i*j);
8. j++;
9. if(j>4) break; //跳出內層循環
10. }
11. printf("\n");
12. i++;
13. if(i>4) break; // 跳出外層循環
14. }
15.  
16. return 0;
17. }

運行結果：

1   2   3   4
2   4   6   8
3   6   9   12
4   8   12  16

當 j>4 成立時，執行break;，跳出內層循環；外層循環依然執行，直到 i>4 成立，跳出外層循環。內層循環共執行了4次，外層循環共執行了1次。

continue語句

continue 語句的作用是跳過循環體中剩余的語句而強制進入下一次循環。continue語句只用在 while、for 循環中，常與 if 條件語句一起使用，判斷條件是否成立。

來看一個例子：

1. #include
2. int main(){
3. char c = 0;
4. while(c!='\n'){ //回車鍵結束循環
5. c=getchar();
6. if(c=='4' || c=='5'){ //按下的是數字鍵4或5
7. continue; //跳過當次循環，進入下次循環
8. }
9. putchar(c);
10. }
11. return 0;
12. }

運行結果：
0123456789↙
01236789

程序遇到while時，變量c的值為'\0'，循環條件c!='\n'成立，開始第一次循環。getchar() 使程序暫停執行，等待用戶輸入，直到用戶按下回車鍵才開始讀取字符。

本例我們輸入的是 0123456789，當讀取到4或5時，if 的條件c=='4'||c=='5'成立，就執行 continue 語句，結束當前循環，直接進入下一次循環，也就是說putchar(c);不會被執行到。而讀取到其他數字時，if 的條件不成立，continue 語句不會被執行到，putchar(c);就會輸出讀取到的字符。

break與continue的對比：break 用來結束所有循環，循環語句不再有執行的機會；continue 用來結束本次循環，直接跳到下一次循環，如果循環條件成立，還會繼續循環。

 

goto 語句, 好多人都是主張慎用,禁用的,這裡就不講了,基本上也用不到.