通用控制语句总结

 

顺序流程

你喝一杯水，一般是这样：
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++)
{
   跑一圈……;
}