通用控制語句總結

 

順序流程

你喝一杯水，一般是這樣：
1， 往杯裡倒滿開水；
2， 等開水冷卻；
3， 往嘴裡倒。
從這個生活的例子中，你可以想到，完成事情，
總是要有順序的，並且執行順序往往還很需講究。
譬如喝水的例子，如果你把第2步和第3步調序，結局可能會很難受；
而如果你想把第1步放到最後去執行，大概你將永遠也喝不了水。
程式是用來解決現實生活的問題的，所以流程在程式中同樣重要。
我們已經學習過語句，當我們寫下一行行代碼時，
這些代碼必須按照一定次序被執行，這就是程式的流程。
我們先為熟悉最簡單的流程：順序流程。
一道很簡單的加法題C++文法格式
//---------------------------------------------------------------------------
現在，我們來加入實現加法計算的代碼：
#include <iostream.h>
int main ()
{
int js1,js2; //加數1，加數2
int he;      //和
js1=58;
js2=42;
he = js1 + js2;   // 和 = 加數1 + 加數2
cout << js1 << " + " << js2 << " = " << he << endl;
return 0;
}
這個程式編譯後，運行結果是：　58+42=100
//---------------------------------------------------------------------------
下面為圖形介面的按鈕控制項進行加法的順序計算
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   int js1,js2,he;
　js1 = Edit1->Text.ToIntDef(0);
   js2 = Edit2->Text.ToIntDef(0);
　he = js1 + js2;
   Edit3->Text = IntToStr(he);
}

 

//*************************************************************
條件分支語句- -
1 if...else 語句
2 if... 語句
3 ? : 運算式
4 多級 if...else...語句
5 switch 語句
　"to be or not be"? 這個問題深深地困擾著哈姆雷特。
他必須在“生存還是毀滅”之間做出一個選擇，這是一個困難的選擇。
在你的人生中，您曾經面對什麼選擇？
“學編程還是不學編程”？“學CB還是學VC”？
選擇哪一個，最終總要是要決定，不同的是每個人在作出選擇時所要面對的不同條件。
前一章我們講“順序流程”就好像長安街一樣筆直的，從頭走到尾；
這一章我們要講的“條件分支流程”，就像是在道路上遇到了分叉，是直行還是右拐？
全看程式走到分叉時所碰上的條件。
　
9.1 if...else  語句
if，中文意思“如果”……
痞子蔡說: “如果把整個太平洋的水倒出，也澆不熄我對你愛情的火”。
當然，如果你學了編程，學了本章，你就會明白這是一句多麼冰涼的條件分支語句，
正如它後面的那句所揭示的一切：“整個太平洋的水全部倒得出嗎？不行。所以我並不愛你”。
來看看if...else 語句在C,C++語言中如何使用。
　
if...else 文法格式：
if (條件)
{
  分支一
}
else
{
  分支二
}
用一句表達，就是：如果條件成立（也稱條件為真），那麼程式執行分支一中的語句，否則（條件為假）程式執行分支二的語句。
這就是if...else語句。舉一生活中的例子：
　if (我中了這一期體彩的500萬大獎）
{
  我買房；
  我買車；
  我去歐洲旅遊；
}
else
{
  我要修理單車；
  我買下一期體彩，
　我繼續燒香。
}

代碼

#include <iostream>
using namespace std;
int main()
{
  int num;
　cout << "請輸入一個整數：";
　cin >> num;
　if((num % 2) == 0)
     cout << num << "是一個偶數。" << endl;
  else
     cout << num << "是一個奇數。" << endl;
  return 0;
}

if...else...中的 else(否則)並不是必須的，因為有時候，當指定條件成立時，我們執行某些動作，否則，我們不執行那些動作。

-----------------------------------------------------------------------------
if...語句格式：
　
if (條件)
{
   分支一
}
代碼如下：
#include <iostream>
using namespace std;
int main()
{
char a;
  cout << "請輸入一個字元：" ;
  cin >> a;
  if(a >= 'a' && a <= 'z')
     cout << a << "是一個小寫字母。" << endl;
  return 0;
}

? :  運算式
? :  運算式 我們稱為 問號冒號運算式。
if (a > b)
   c = 1;
else
   c = 0;
沒有花括弧的代碼，感覺多緊湊。不過對於上面的代碼，我們還可以繼續簡化，那就是使用 ? : 語句。
　 c = (a > b)? 1 : 0;
　 就一行話，多簡捷！
語句中的問號問的是什嗎？問的是 a 是否大於 b ? 如果是，則得到值1，否則，得到值0。
? : 運算式格式文法：
　 (條件) ? 值1 : 值2
　 舉一例子：設有int變數 a,b，二者均已初始化。請得到二者中的較大值。
　 方法是： 　 int c = (a  > b) ?  a : b;
並不是所有的if..else...語句都可以用 : ? 來代替，
只有那些兩個分支都只是用來計算一個同一類型的值，然後賦予同一變數的條件分支語句，才適合。
代碼實現
#include <iostream>
using namespace std;
int main()
{
  int a,b,c;
  cout << "請輸入兩個整數（用空格分開）：" ;
  cin >> a >> b;
    c = (a > b)? a : b;
    cout << c << "大" << endl;
  return 0;
}

-----------------------------------------------------------------------------------------------

多級 if..else...文法格式：
　
if(條件1)
{
　　  分支一　　
}
   else if(條件2)
{
      分支二
}
   else if(條件3)
{
　　　分支三
}
   else
{
　　　分支四
 }
　
格式中舉出四個分支，實際可以只有三個，兩個，也可以有更多個。請看下在這個例子。

讓我們想像這麼一幕情景劇??時間：XXXX年2月14日；地點：某校園內小公園；
     人物：女生一，男生一。
    （男生送給女生一束環瑰）
     女生（高興地）：多美啊??多少錢買的！
     男生：猜。
     女生（心裡想：如果多於100元我就親他一口）：超過100元嗎？
     男生：NO。
     女生：（心裡想：如果多於50元我就許他親我一口）：那，不低於50元吧？
     男生：NO。
     女生：（心裡想：如果多於10元就跟他說聲謝謝吧）：那是不低於10元了？
     男生：NO。
     女生：（不再有任何想法，一把丟掉鮮花）：呸！
看明白了嗎？“看明白了……”一個小男生眼淚汪汪地站起來，

回答：“我是看明白了，現在的女生沒一個是好東西寫成程式，便是：
　
int price = 玫瑰花價錢;

   if (price > 100)
{
        小女生要親小男生一口;
}
   else if(price > 50)
{
        小女生準備讓小男生親一口;
}
   else if (price > 10)
{
       小女生對小男生說聲“謝謝”;
 }
   else
{
       小女生扔掉花，說：“呸！”;
}

如果花價大於１００元，那麼女生親男生一口；否則呢？否則就再判斷花價是否大於５０元，

如果還是不大，那不再來判斷花價是否大於１０元，如果還是不大，最後無條件地執行“小女生扔掉花……”這一句。

 

#include <iostream>
using namespace std;
int main()
{
　int flowerPrice;  
  cout << "公元2018年２月１４日，一小男生向一小女生贈送一束玫瑰……" << endl;
  cout << "女生：請輸入這束花的價錢。" << endl;
  cout << "男生：";
  cin  >> flowerPrice;
  
  if(flowerPrice > 100)
     cout << "女生：哇！我太喜歡這花了，讓我親你一口以示謝意！" << endl; 
  else if (flowerPrice > 50)
     cout << "女生：哈！花美人更美，你不想親我一口嗎？" << endl;
  else if (flowerPrice > 10)
     cout << "女生：謝謝！" << endl;
  else 
     cout << "女生：什麼破花，大頭鬼才會喜歡。" << endl;
  return 0;
}

-----------------------------------------------------------------------------------------------

switch 語句

switch 語句的格式： 

switch ( 整型或字元型變數 )
{
   case 變數可能值1 ：
      　  分支一;
        　break;
   case 變數可能值2 ：
      　  分支二;
        　break;
   case 變數可能值3 ：
      　  分支三;
        　break;
   ...
   default :
       最後分支;
｝
　
在 switch 的文法裡，我們要學到4個關鍵字：switch、case 、break、default。
在　switch ( 變數 )　這一行裡，變數只能是整型或字元型。
程式先讀出這個變數的值，然後在各個"case"裡尋找哪個值和這個變數相等，
如果相等，就算條件成立，程式執行相應的分支，直到碰上break或者switch語句結束。
說起來有點抽象。我們結合一個執行個體看看。
執行個體類比一個網上調查。它要求網友輸入數字以選擇自已是如何到達當前網頁。
然後，程式根據網友這一輸入，打出不同的結果。
程式根據網友的選擇，輸出相應不同的結果。請建立一控制台空白工程，然後在代碼裡輸入以下黑體部分。
//---------------------------------------------------------------------------
#include <iostream.h>
using namespace std;
int main()
{
  int fromWay; 　
  cout << "請通過輸入序號，選擇您如何來到本網站。" << endl;
  cout << "1) ---- 通過搜尋引擎" << endl;
  cout << "2) ---- 通過朋友介紹" << endl;  
  cout << "3) ---- 通過報刊雜誌" << endl;
  cout << "4) ---- 通過其它方法" << endl; 　
  cin >> fromWay;
　
  switch (fromWay)
  {
    case 1 : 
       cout << "您是通過搜尋引擎來到本網站的。" << endl;
       break;
    case 2 : 
       cout << "您是通過朋友介紹來到本網站的。" << endl;
       break;
    case 3 : 
       cout << "您是通過報刊雜誌來到本網站的。" << endl;
       break;
    case 4 : 
       cout << "您是通過其它方法來到本網站的。" << endl;
       break;
    default :
       cout << "錯誤的選擇！請輸入１～４的數字做出選擇。" << endl;
  } 　 　
   return 0;
}

switch (fromWay)
程式將根據　fromWay　值，在下面的各個case 中找到匹配的值。　
本例中switch帶有四個case，值分別是1、2、3、4。
在結果圖中，由於我輸入的是２，所以程式進入下面這個case:
case 2 : 
    cout << "您是通過朋友介紹來到本網站的。" << endl;
    break; 　
程式打出"您是通過朋友介紹來到本網站的。" 這行內容。最後遇上 break;於是跳出整個switch語句。
　
同樣的道理，如果使用者輸入的是其它的數，如１或３，則會進入相應的case 1 或　case 3　分支。
但如果使用者輸入的數在所有的case 裡都找不到時，會怎麼樣？比如，使用者輸入５。
這種情況下，default分支將起作用，所有case裡的值都不匹配時，switch進入default分支。
如果連default也沒有，那麼程式在switch語句裡什麼也不做，直接完成switch語句。
瞭解一下switch,case,break，default的意思，它們分別是：開關，情況，中斷，預設（值）。
那麼用一句話套起來的說法就是：根據開關值的不同，執行不同的情況，直到遇上中斷；
如果所有的情況都不符合開關值，那麼就執行預設的分支。
最後說一下關於switch中非常重要的幾個注意點。 　
第一、switch ( 整型或字元型變數 )　中，變數的類型如文中所標，只能是整型和字元類型。
它們包含 int,char。當然無符類型或不同的長度整型(unsigned int,short,unsigned char)等都可以。
另外，枚舉類型(enum)內部也是由整型或字元類型實現。
實型（浮點型）數就不行，如：float a = 0.123;
switch(a) //錯誤！a不是整型或字元類型變數。  
{
  ....
}
　
第二、case　之後可以是直接的常量數值，如例中的1.2.3.4也可以是一個使用常量計算式，如２+2等，

但不能是變數或帶有變數的運算式，如 a * 2等。
當然也不能是實型數，如4.1，或２.0 / 2　等。
switch(formWay)
{
   case 2-1 :  //正確
     ...
   case a-2 :  //錯誤
     ...
   case 2.0 :  //錯誤
     ...
}
另外，在case　與常量值之後，需要一個冒號，請注意不要疏忽。
　
第三、break 的作用。
break 使得程式在執行完選中的分支後，可以跳出整個switch語句（即跳到switch接的一對｛｝之後），完成switch。
如果沒有這個break,程式將在繼續前進到下一分支，直到遇到後面的break或者switch完成。
比如，假設現在程式進入case 1: 中的分支，但case 1　的分支這回沒有加break:
　
case 1 :
    cout << "您是通過搜尋引擎來到本網站的。" << endl;
case 2 : 
    cout << "您是通過朋友介紹來到本網站的。" << endl;
　
那麼，程式在輸出　"您是通過搜尋引擎來到本網站的。
" 之後，會繼續輸出case 2中的　"您是通過朋友介紹來到本網站的。" 。
請大家將前面執行個體中的程式碼片段改為如下(紅色部分，即將所有的break都通過加//使之無效。

　　case 1 : 
       cout << "您是通過搜尋引擎來到本網站的。" << endl;
       //break;
    case 2 : 
       cout << "您是通過朋友介紹來到本網站的。" << endl;
       //break;
    case 3 : 
       cout << "您是通過報刊雜誌來到本網站的。" << endl;
       //break;
    case 4 : 
       cout << "您是通過其它方法來到本網站的。" << endl;
       //break;
    default :
       cout << "錯誤的選擇！請輸入１～４的數字做出選擇。" << endl;
    ...
　
運行後，結果會是如何？請大家動手試試，然後在作業中回答我。
　
第四、default是可選中，前面我們已經說過它的用處，及如果沒有default，
程式在找不到匹配的case分支後，將在switch語句範圍內不做什麼事，直接完成switch。
大家也可以在執行個體中將default的代碼注釋掉，然後試運行，並且在選擇時輸入５。
...
//default :
   //cout << "錯誤的選擇！請輸入１～４的數字做出選擇。" << endl;
...
　
第五、必要時，可在各個case中使用{}來明確產生獨立的複合陳述式。
前面我們在講if...語句和其它流程式控制制語句時，都使用{}來產生複合陳述式：
if (條件)
{
  分支一;
}
除非在分支中的語句正好只有一句，這裡可以不需要花括弧{}。
但在switch的各個case語句裡，我們在文法格式上就沒有標出要使用｛｝，請看：
switch ( 整型或字元型變數 )
{
    　case 變數可能值1 ：
      　  分支一;
        　break;
   case 變數可能值2 ：
      ....
}
　
一般教科書上只是說 case 分支可以不使用｛｝，但這裡我想提醒大家，
並不是任何情況下case分支都可以不加{}，比如你想在某個case裡定義一個變數：
switch (formWay)
{
   case 1 :
     int a=2;  //錯誤。由於case不明確的範圍，編譯器無法在此處定義一個變數。
     ...
   case 2 :
     ...
}
　
在這種情況下，加上｛｝可以解決問題。
switch (formWay)
{
   case 1 :
　｛　
     int a=2;  //正確，變數a被明確限定在當前｛｝範圍內。
     ...
 　｝　
   case 2 :
     ...
}
由於本注意點涉及到變數的作用範圍，所以你如果看得不是很明白，可以暫時放過。 　
第六、switch並不能代替所有有if..else...語句。這一點你應該知道了，因為前面已說過，
它在對變數做判斷時，只能對整型或字元型的變數做判斷。
另外，switch也只能做“值是否相等”的判斷。你不能在case裡寫條件： 　
switch (i)
{
  case (i >= 32 && i<=48) //錯誤！　case裡只能寫變數的可能值，不能寫條件。
     ...
}
　
在這種情況下，你只能通過 if...else來實現。
　
**********************************************************************
迴圈
1 while 迴圈
2 do ... while 迴圈
3 for 迴圈　　迴圈條件三要素,三要素在for迴圈結構上體現
4 多層迴圈
5 小結及一點問題
　
　
迴圈就是反覆。 生活中，需要反覆的事情很多。
譬如你我的整個人生，就是一個反覆，反覆每一天的生活，直到死，幸好，我們每天的生活並不完全一個樣。  
while 迴圈　
文法形式： 　
while(條件)
{
  需要迴圈執行的語句; 
} 
 

while 是“當”的意思。 請首先和if語句作一個比較：
　
if(條件)
{
  條件成立時執行的語句;
}
　
二者除了關鍵字不一樣以外，結構完全一樣。
但一定要注意，在條件成立時，if語句僅僅執行一遍，而while語句則將反覆執行，直到條件不再成立。 
程式從“前面的語句”開始執行，然後進行條件判斷，如果條件成立，則執行一次“每次迴圈執行的語句”，
再後請特別注意紅色部分，這是我們碰上的
，第一次會往後走流程：紅線就像汽車拐彎，迴轉到條件處（並不包括前面的語句），
然後再進行下一次的條件判斷……直到某一次判斷時條件不成立了，程式“繼續後面的語句”。 　
　
我們用while的文法套用生活中的實際例子，可以直觀地看出while的用法。
假設有一個愛哭的小娃娃，有一天她要求父母給買一條小紅裙，可惜父母不同意，於是她就開始一個迴圈：
  
while ( 父母不給買小紅裙)
{
      我哭;
   }
　
這段“代碼”的意思是：當“父母不給買小紅裙”，那麼，小女孩就一遍一遍地哭。
這就是我們和迴圈流程的第一個遭遇戰。
所舉的例子看似直觀：“小孩一遍遍地哭，直到父母給買裙”，
但真正要用程式的語言來正確地表達出來，需要很多方面要考慮到，必竟，程式是嚴謹的。
首先，一個合適的判斷是否繼續的條件相當重要。
小女孩要繼續哭，僅僅“父母不給買小紅裙”，這顯示不符合事實，
想想我們小時候，再會哭，最終也有累的時候，所以，
要想繼續哭，我們的條件有兩個：“父母不給買小紅裙”並且“我還沒有哭累”。
while ( 父母不給買小紅裙 && 我還沒有哭累)
{
      我哭;
   }
　
其次，大多數情況下，條件需要被恰當地改變。
小女孩在不停地哭，那麼她如何知道父母是否買了紅裙呢？
所以，她不能只顧哭，還得在哭的間隙觀察大人是否同意買裙。
至於是否哭累，我們假設小女孩有一個疲勞度，每哭一次疲勞度加1，當疲勞度到達200時，可憐的小女孩累了……
　
while(父母不給買小紅裙 && 疲勞度 < 200）
{
  我哭;
  我偷看爸媽是否同意買裙;
  疲勞度++;
}
　
例一： 用 while 語句實現求從1到100的累加和。 　
求1＋2的和，我們可以寫 a = 1 + 2;求1加到100，
我們當然可以這樣寫 a = 1 + 2 + 3 + ... 100.不過這樣寫顯然太累人了，
要從1寫到100啊！所以聰明如高斯的你，
當然也知道這樣寫：a = (1+100) * 50;這確實是個在任何時候都值得稱讚的，又快又簡的方法，
只是今天我們想讓電腦累一點，老老實實地從1加到100。
首先用我們先學的while式的迴圈。 　
 
//---------------------------------------------------------------------------
#include <iostream.h>
using namespace std;

int main()
{
int sum = 0; //變數sum將用於儲存累加和，將它初始化為0，這很重要。
int i = 1; //i是每次要加的數，它從1開始。
　
while ( i<= 100)
{
   sum += i;
   i++;
} 

//輸出累加結果：
cout << "1到100的累加和為：" << sum << endl;
getchar();
}　
sum 初始為0，然後在每一遍的迴圈裡，它都加上i，而，i則每次都在被加後，增加1。
最終，i遞增到101，超過100了，這個迴圈也就完成了任務。
　
運行上面程式，輸出結果為：
　
1到100累加和為為：5050
　
do ... while 迴圈
　
文法形式：
　
do
{
    需要迴圈執行的語句; 
}
while(條件);
　
和 while迴圈最明顯的區別，就是do...while迴圈中，判斷是否繼續迴圈的條件，放在後面。
也就是說，就算是條件一開始就不成立，迴圈也要被執行一次。
請比較以下兩段代碼，前者使用while迴圈，後者使用do...while迴圈。
　
程式碼片段一：
int a = 0;
while( a > 0 )
{
  a--;
}
　
變數a初始值為 0,條件 a > 0 顯然不成立。所以迴圈體內的 a--;語句未被執行。
本段代碼執行後，變數a值仍為0；
　
程式碼片段二：
int a = 0;
do 
{
  a--;
}
while( a > 0 );
　
儘管迴圈執行前，條件 a > 0 一樣不成立，但由於程式在運行到 do...時，
並不先判斷條件，而是直接先運行一遍迴圈體內的語句：a--。
於是a的值成為 -1，然後，程式才判斷 a > 0 ，發現條件不成立，迴圈結束。
　
do..while中的條件和while迴圈中的條件一樣是：“允許繼續迴圈的條件”，
而不是“結束迴圈的條件”
這和Pascal語言中的do...until正好相反，學習過Pascal(Delphi)的學員可得注意。 　
以筆者的經驗，do..while迴圈用得並不多，大多數的迴圈用while...來實現會更直觀。
下面我們僅簡單地將1到100的連加程式轉換為用do...while實現：
　
int sum =0;
int i=1;
　
do
{
   sum += i;
   i++;
}
while(i<=100);
　 
3 for 迴圈
for 迴圈裡在Ｃ，Ｃ＋＋裡用得最多，也是最靈活的迴圈語句。
要學好它，需要從已經學過的while迴圈的身上，“挖掘”出有關迴圈流程的要素，
這些要素隱藏在while,或do...while的背後，但它將直接體現在for迴圈的結構上。
1 迴圈條件三要素學習了兩種迴圈，我們來挖掘一下迴圈流程中的“條件三要素”。 
第一、條件一般需要進行一定的初始化操作。請看我們用while迴圈實現1到100累加的代碼： 　
int sum = 0; //變數sum將用於儲存累加和，將它初始化為0，這很重要。
int i = 1;   //i是每次要加的數，它從1開始。 　
while ( i<= 100)
{
   sum += i;
   i++;
}
　
這段代碼中，迴圈的條件是 i <= 100;因此，一開始，i肯定需要一個確定的值。前面的：
int i = 0;這一行代碼，在聲明變數i的同時，也為i賦了初始值：1。
這樣，條件 i <= 100 得以成立（因為i為1，所以 i <= 100 當然成立）。 
第二、迴圈需要有結束的機會。 　
程式中最忌“死迴圈”。所謂的“死迴圈”就是指該迴圈條件永遠為真，
並且，沒有另外的跳出迴圈的機會（後面將學到）。
比如： //一段死迴圈的例子：
while ( 2 > 1 )
{
  cout << "死迴圈" <<endl; 
}
　
執行這段代碼，你會發現程式停不下來了。原因就是它的迴圈條件 2 > 1 永遠為true。
所以，一個最後可以變成不成立條件在大多數情況下是必需的。比如在while的那個例子：
while ( i<= 100)
條件　i <= 100 ，由於　i 在迴圈中被改變，所以它至少在理論上有可能造成 i <= 100 不成立。
　
第三、在迴圈中改變迴圈條件的成立因素 
這一條和第二條互相配套。
比如這段代碼：
int i=1;
while ( i<= 100)
{
   sum += i;
}
同樣是一段可怕的“死迴圈”。因為i沒有被改變的機會，其值永遠為１，從而迴圈條件 i<=100也就永遠為真。
所以在迴圈中最後一句(下面加粗部分)，不可遺忘。
while ( i<= 100)
{
   sum += i;
   i++;
}
當然，在這段程式裡，i++除了起改變條件成立因素以外，同時也起上sum不斷加遞增的數，從而實現得到累加和。
　
說完這一些，我們來看Ｃ，Ｃ＋＋中最靈活迴圈結構：for迴圈。
　 
三要素在for迴圈結構上體現
for 迴圈的文法：
　
for(條件初始化;條件;條件改變)
{
  需要迴圈執行的語句; 
}
　
可見，for的結構中，不僅提供了的“條件”的位置，同時也提供了條件初始化，和條件改變的位置。
這三者雖然在同一行上，但並不是依次串連地執行。
　
條件初始化的運算式首先被執行（並且只被執行一次）；
然後程式檢查條件是否成立，如果成立就執行迴圈體中的語句，否則直接結束迴圈。
執行完一遍迴圈以後，程式執行“條件改變”語句。
　
１到100整數累加的程式，改為for迴圈寫，是最合適的了：
　
int sum = 0;
int i;
　
for( i=1; i <= 100;i++)
{
  sum += i;
}
　
程式先執行條件初始化語句：i=1;
然後立即判斷條件　i <= 100 嗎？顯示，此時該條件成立；
於是程式執行迴圈體內的語句，此時只有一句： sum += i;
然後，執行改變條件因子的語句：　i++;　此時，i值變為 2;
程式再次判斷條件 i <= 100 ?，依然成立，於是開始第二遍迴圈……
　
變數　i 可以初始化條件時才臨時聲明：
for(int i = 1;i <= 100;i++) ……
　
for 語句的複合結構，使得程式變得簡捷。比如上面的例子中，
原來　while或者do...while結構中，迴圈體內必須兩句語句，現在只需一句（即：i++這一句被移到for的特定位置上），
這樣，我們可以去除花括弧：
for(int i=0;i <= 100;i++)
   sum += 100;
當然，如果在其它情況下，for的迴圈體內仍需有多行語句時，｛｝仍是不可避免的。
事實上，就算現在這種情況，我也建議大家使用花括弧。這樣可以讓程式的結構看上去更清晰。
　
在本例中，如果非要講究簡捷，我們還可以將迴圈體內的那惟一的一行移到“條件改變”的位置：
for(int i=1; i<=100;sum += i,i++);
sum += i和i++之間用逗號分開。而在for後面的()行末，則直接跟上分號，表示for不必再執行其它的語句。
考慮到後置++的特性（在完成運算式的求值後，才進行加１操作），也可以將sum += i和i++合為一句：
for(int i=1;i<=100;sum += i++);
　
以上講了for語句極盡合并之技巧，以求一個簡捷。反過來，for語句也可以向 while或do...while語句一樣拆開寫：
　
int i = 1;
for(; i <= 100;)
{
  sum += i;
  i++;
}
　
看，條件初始化語句被移出for的結構，而條件改變語句則被當成一行普通語句，直接加入到迴圈體內。
而在相應的位置上，只留下分號，用於表示空語句（請注意這一行中有2個分號,分別在 i<=100前後）：
for (; i <= 100;)
如上行所示，for迴圈結構中的“條件初始”和“條件的改變”運算式都被省略，
在這種情況下for和while或do...while迴圈完全一樣。比如求１～１００累加和：
int i=1,sum=0;
for(;i<=100;)
{
  sum += i;
  i++;
} int i=1,sum=0;
while(i<=100)
{
  sum += i;
  i++;
}

10.5 小結及一點問題
　
學習了三種迴圈流程：while,do...while,for。
　
while在每一遍迴圈開始時檢查條件是否成立，如果一開始條件就不成立，則迴圈中的語句將一次也沒有執行。
　
do...while的特殊之處在於，第一遍迴圈前，並不檢查條件，
所以就算條件根本就不成立，迴圈也將並執行一次，如：
do
{
  ...
}
while(false);
條件是“false”？這也是條件嗎？是的，這也是條件，
一個擺明了就是不成立的條件，常見的還有：while(0)。
0可以看false。相反的，擺明是真的條件是：while(true)或while(1)等。
　
for 的特殊之處在於，它除了條件判斷以外，還明確地留出了條件初始化，條件變化的位置。
所以，有關計數的迴圈最適於用for來實現，請參看課程中用for實現1到100累加的執行個體。
至於for的各種“變體”，迴圈就象繞圈子。
比如，體育課，跑1200米，跑道一圈400米，所以我們要做的事就是一邊跑一邊在心裡計數
（當然要已數，否則老師萬一少計一圈，我們可就玩完了），當計數到3圈時，“迴圈”結束。
在這個例子，條件初始化就將計數設為0；迴圈的條件則是計數小於3；
條件變化則是指在每跑完一圈時，心裡將計數加1；至於迴圈的動作，自然就是跑步了……

用while實現： 
int js = 0; //js 取意“計數”，　
while( js < 3)
{
  跑一圈……;
  js++;
}
　
用do...while實現： 　
int js = 0; 　
do
{
  跑一圈……
  js++;
}
while( js <3);
　
用 for 實現（最適合了） 　
for(int i=0;i<3;i++)
{
   跑一圈……;
}