zoukankan      html  css  js  c++  java

  • 分支结构和循环结构

    1.C语言关系运算符

    在程序中经常需要比较两个数据的大小，以决定程序下一步的工作。比如一个程序限制了只能成年人使用，儿童因为年龄不够，没有权限使用。这时候程序就需要获取用户输入的年龄并做出判断，如果超过18岁就正常运行，否则给出无权使用的提示。
     
    比较两个数据大小的运算符称为关系运算符（Relational Operators）。
     
    在C语言中有以下关系运算符：
    1) <（小于）
    2) <=（小于或等于）
    3) >（大于）
    4) >=（大于或等于）
    5) ==（等于）
    6) !=（不等于）
     
    关系运算符都是双目运算符，其结合性均为左结合。关系运算符的优先级低于算术运算符，高于赋值运算符。在六个关系运算符中，<、<=、>、>=的优先级相同，高于==和!=，==和!=的优先级相同。
     
    关系运算符的两边可以是变量、数据或表达式，例如：
    1) a+b>c-d
    2) x>3/2
    3) 'a'+1<c
    4) -i-5*j==k+1
     
    关系运算符也可以嵌套使用，例如：
    1) a>(b>c)
    2) a!=(c==d)
     
    关系运算符的运算结果为 0 或 1，如：
    5>0 成立，其值为 1；
    34-12<100 不成立，其值为 0；
    (a=3)>(b=5) 由于3>5不成立，故其值为 0。
     
    我们将运算结果 1 称为“真”，表示条件成立，将 0 称为“假”，表示条件不成立。
     
    我们不妨将关系运算符的结果输出看一下：
    1. #include <stdio.h>
    2. int main(){
    3.     char c='k';
    4.     int i=1, j=2, k=3;
    5.     float x=3e+5, y=0.85;
    6.     printf( "%d,%d
", 'a'+5<c, -i-2*j>=k+1 );
    7.     printf( "%d,%d
", 1<j<5, x-5.25<=x+y );
    8.     printf( "%d,%d
", i+j+k==-2*j, k==j==i+5 );
    9.     return 0;
    10. }

    运行结果：
    1,0
    1,1
    0,0
     
    对于含多个关系运算符的表达式，如 k==j==i+5，根据运算符的左结合性，先计算k==j，该式不成立，其值为0，再计算0==i+5，也不成立，故表达式值为0。

    2.C语言逻辑运算符

    在高中数学中，我们学过逻辑运算，例如p为真命题，q就假命题，那么“p且q”为假，“p或q”为真，“非q”为真。
     
    在C语言中，也有类似的逻辑运算：
    运算符
    		说明
    		结合性
    		举例
    &&
    		与运算，双目，对应数学中的“且”
    		左结合
    		1&&0、(9>3)&&(b>a)
    ||
    		或运算，双目
    		左结合
    		1||0、(9>3)||(b>a)
    !
    		非运算。单目
    		右结合
    		!a、!(2<5)

    ①.逻辑运算的值

     
    逻辑运算的值也为“真”和“假”两种，用“1”和“0 ”来表示，其求值规则如下。
     
    1) 与运算(&&)
    参与运算的两个量都为真时，结果才为真，否则为假。例如：
        (5>0) && (4>2)
    由于5>0为真，4>2也为真，相与的结果也为真。
     
    2) 或运算(||)
    参与运算的两个量只要有一个为真，结果就为真。 两个量都为假时，结果为假。例如：
        (5>0) || (5>8)
    由于5>0为真，相或的结果也就为真。
     
    3) 非运算(!)
    参与运算量为真时，结果为假；参与运算量为假时，结果为真。例如：
        !(5>0)
    的结果为假。
     
    注意：在逻辑运算中，0 为假，非 0 值都是真，例如5为真，2*3为真。对于表达式(3+5)&&(9>3)，由于3+5=8为真，9>3为真，所以结果也为真。

    ②.优先级

     
    逻辑运算符和其它运算符优先级从低到高依次为：赋值运算符(=) < &&和|| < 关系运算符 < 算术运算符 < 非(!)
     
    “&&”和“||”低于关系运算符，“!”高于算术运算符。
     
    按照运算符的优先顺序可以得出：
    1. a>b && c>d  等价于  (a>b)&&(c>d)
    2. !b==c||d<a  等价于  ((!b)==c)||(d<a)
    3. a+b>c&&x+y<b  等价于  ((a+b)>c)&&((x+y)<b)
     
    另外，逻辑表达式也可以嵌套使用，例如 a>b && b || 9>c，a || c>d &&  !p。
     
    逻辑运算符举例：
    1. #include <stdio.h>
    2. int main(){
    3.     char c='k';
    4.     int i=1,j=2,k=3;
    5.     float x=3e+5,y=0.85;
    6.     printf( "%d,%d
", !x*!y, !!!x );
    7.     printf( "%d,%d
", x||i&&j-3, i<j&&x<y );
    8.     printf( "%d,%d
", i==5&&c&&(j=8), x+y||i+j+k );
    9.     return 0;
    10. }

    运行结果：
    0,0
    1,0
    0,1
     
    本例中!x和!y分别为0，!x*!y也为0，故其输出值为0。由于x为非0，故!!!x的逻辑值为0。对x|| i && j-3式，先计算j-3的值为非0，再求i && j-3的逻辑值为1，故x||i&&j-3的逻辑值为 1。对i<j&&x<y式，由于i<j的值为1，而x<y为0故表达式的值为1，0相与，最后为0，对i==5&&c&&(j=8)式，由于i==5为假，即值为0，该表达式由两个与运算组成，所以整个表达式的值为0。对于式x+ y||i+j+k由于x+y的值为非0，故整个或表达式的值为1。

    3.C语言if else语句

    前面我们看到的代码都是顺序执行的，也就是先执行第一条语句，然后是第二条、第三条……一直到最后一条语句。
     
    但是对于很多情况，顺序结构的代码是远远不够的，比如一个程序限制了只能成年人使用，儿童因为年龄不够，没有权限使用。这时候程序就需要做出判断，看用户是否是成年人，并给出提示。

    ①.if-else语句

     
    在C语言中，使用if语句进行判断，请先看下面的代码：
    1. #include <stdio.h>
    2. int main()
    3. {
    4.     int age;
    5.     printf("请输入你的年龄：");
    6.     scanf("%d", &age);
    7.     if(age>=18){
    8.         printf("恭喜，你已经成年，可以使用该软件！
");
    9.     }else{
    10.         printf("抱歉，你还未成年，不宜使用该软件！
");
    11.     }
    12.     return 0;
    13. }
    可能的运行结果：
    请输入你的年龄：23↙
    恭喜，你已经成年，可以使用该软件！
     
    if else 语句的结构为：
    if(表达式){
        语句块1
    }else{
        语句块2
    }
     
    意思是：如果表达式的值为真，则执行语句块1，否则执行语句块2 。其执行过程可表示为下图：

     
    所谓语句块（Statement Block），就是由{ }包围的一个或多个语句的集合。如果语句块中只有一个语句，也可以省略{ }，例如：
    1. if(age>=18) printf("恭喜，你已经成年，可以使用该软件！
");
    2. else printf("抱歉，你还未成年，不宜使用该软件！
");
    由于if else 语句可以根据不同的情况执行不同的代码，所以也叫分支结构或选择结构，上面的代码中，就有两个分支。
     
    求两个数中的较大值：
    1. #include <stdio.h>
    2. int main()
    3. {
    4.     int a, b, max;
    5.     printf("输入两个整数：");
    6.     scanf("%d %d", &a, &b);
    7.     if(a>b) max=a;
    8.     else max=b;
    9.     printf("%d和%d的较大值是：%d
", a, b, max);
    10.     return 0;
    11. }
    运行结果：
    输入两个整数：34 28↙
    34和28的较大值是：34
     
    本例中借助变量max，用max来保存较大的值，最后将max输出。

    ②.if语句

     
    我们可以只使用 if 语句，也就是说，if else不必同时出现。if 语句的基本形式为：
    if(表达式){
        语句块
    }
     
    意思是：如果表达式的值为真，则执行其后的语句块，否则直接跳过。其过程可表示为下图：
     
     
    只使用 if 语句来求两个数中的较大值：
    1. #include <stdio.h>
    2. int main()
    3. {
    4.     int a, b, max;
    5.     printf("输入两个整数：");
    6.     scanf("%d %d", &a, &b);
    7.     max=b;  // 假设b最大
    8.     if(a>b) max=a;  // 如果a>b，那么更改max的值
    9.     printf("%d和%d的较大值是：%d
", a, b, max);
    10.     return 0;
    11. }

    运行结果：
    输入两个整数：34 28
    34和28的较大值是：34
     
    本例程序中，输入两个数a、b。把b先赋予变量max，再用 if 语句判别max和b的大小，如max小于b，则把b赋予max。因此max中总是大数，最后输出max的值。

    ③.多个if else语句

     
    if else语句也可以多个同时使用，构成多个分支，形式如下：
    if(表达式1){
        语句块1
    } else  if(表达式2){
        语句块2
    }else  if(表达式3){
        语句块3
    }else  if(表达式m){
        语句块m
    }else{
         语句块n
    }
     
    意思是：依次判断表达式的值，当出现某个值为真时，则执行其对应的语句。然后跳到整个if语句之外继续执行程序。 如果所有的表达式均为假，则执行语句块n。然后继续执行后续程序。多个 if else 语句的执行过程如下图所示：
     
     
    例如，判断输入的字符的类别：
    1. #include <stdio.h>
    2. int main(){
    3.     char c;
    4.     printf("Input a character:");
    5.     c=getchar();
    6.     if(c<32)
    7.         printf("This is a control character
");
    8.     else if(c>='0'&&c<='9')
    9.         printf("This is a digit
");
    10.     else if(c>='A'&&c<='Z')
    11.         printf("This is a capital letter
");
    12.     else if(c>='a'&&c<='z')
    13.         printf("This is a small letter
");
    14.     else
    15.         printf("This is an other character
");
    16.     return 0;
    17. }
    运行结果：
    Input a character:e
    This is a small letter
     
    本例要求判别键盘输入字符的类别。可以根据输入字符的ASCII码来判别类型。由ASCII码表可知ASCII值小于32的为控制字符。在“0”和“9”之间的为数字，在“A”和“Z”之间为大写字母， 在“a”和“z”之间为小写字母，其余则为其它字符。这是一个多分支选择的问题，用多个 if else 语句编程，判断输入字符ASCII码所在的范围，分别给出不同的输出。例如输入为“e”，输出显示它为小写字符。
     
    在使用if语句时还应注意以下问题：
    1) 在三种形式的if语句中，在 if 关键字之后均为表达式。 该表达式通常是逻辑表达式或关系表达式，但也可以是其它表达式，如赋值表达式等，甚至也可以是一个变量。例如：
        if(a=5) 语句;
        if(b) 语句;
    都是允许的。只要表达式的值为非0，即为“真”。如在：
        if(a=5)…;
    中表达式的值永远为非0，所以其后的语句总是要执行的，当然这种情况在程序中不一定会出现，但在语法上是合法的。
     
    又如，有程序段：
    1. if(a=b)
    2.     printf("%d",a);
    3. else
    4.     printf("a=0");

    本语句的语义是，把b值赋予a，如为非0则输出该值，否则输出“a=0”字符串。这种用法在程序中是经常出现的。
     
    2) 在if语句中，条件判断表达式必须用括号括起来。
     
    3) 语句块由{ }包围，但要注意的是在}之后不要再加分号;。例如：
    1. if(a>b){
    2.     a++;
    3.     b++;
    4. }else{
    5.     a=0;
    6.     b=10;
    7. }

    ④.if语句的嵌套

     
    if 语句也可以嵌套使用，例如：
    1. #include <stdio.h>
    2. int main(){
    3.     int a,b;
    4.     printf("Input two numbers:");
    5.     scanf("%d %d",&a,&b);
    6.     if(a!=b){
    7.         if(a>b) printf("a>b
");
    8.         else printf("a<b
");
    9.     }else{
    10.         printf("a=b
");
    11.     }
    12.     return 0;
    13. }

    运行结果：
    Input two numbers:12 68
    a<b
     
    if 语句嵌套时，要注意 if 和 else 的配对问题。C语言规定，else 总是与它前面最近的 if 配对，例如：
    复制纯文本新窗口
    1. if(a!=b)  // ①
    2. if(a>b) printf("a>b
");  // ②
    3. else printf("a<b
");  // ③
    ③和②配对，而不是和①配对。

    4.C语言switch语句

    用 if else 语句在处理多分支的时候，分支太多就会显得不方便，且容易出现 if 和 else配对出现错误的情况。例如，输入一个整数，输出该整数对应的星期几的英文表示：
    1. #include <stdio.h>
    2. int main(){
    3.     int a;
    4.     printf("Input integer number:");
    5.     scanf("%d",&a);
    6.     if(a==1){
    7.         printf("Monday
");
    8.     }else if(a==2){
    9.         printf("Tuesday
");
    10.     }else if(a==3){
    11.         printf("Wednesday
");
    12.     }else if(a==4){
    13.         printf("Thursday
");
    14.     }else if(a==5){
    15.         printf("Friday
");
    16.     }else if(a==6){
    17.         printf("Saturday
");
    18.     }else if(a==7){
    19.         printf("Sunday
");
    20.     }else{
    21.         printf("error
");
    22.     }
    23.     return 0;
    24. }

    运行结果：
    Input integer number:3↙
    Wednesday
     
    C语言还提供了另外一种多分支选择的语句——switch 语句，它的基本语法格式如下：
    switch(表达式){
        case 常量表达式1: 语句 1;
        case 常量表达式2: 语句 2;
        ......
        case 常量表达式n: 语句 n;
        default: 语句 n+1;
    }
     
    它的执行过程是：首先计算“表达式”的值，然后从第一个 case 开始，与“常量表达式x”进行比较，如果与当前常量表达式的值不相等，那么就不执行冒号后边的语句 x，一旦发现和某个常量表达式的值相等了，那么它会执行之后所有的语句，如果直到最后一个“常量表达式 n”都没有找到相等的值，那么就执行 default 后的“语句 n+1”。
     
    需要注意的是，当找到一个相等的 case 分支后，会执行该分支以及之后所有分支的语句。例如：
    1. #include <stdio.h>
    2. int main(){
    3.     int a;
    4.     printf("Input integer number:");
    5.     scanf("%d",&a);
    6.     switch(a){
    7.         case 1: printf("Monday
");
    8.         case 2: printf("Tuesday
");
    9.         case 3: printf("Wednesday
");
    10.         case 4: printf("Thursday
");
    11.         case 5: printf("Friday
");
    12.         case 6: printf("Saturday
");
    13.         case 7: printf("Sunday
");
    14.         default:printf("error
");
    15.     }
    16.     return 0;
    17. }

    运行结果：
    Input integer number:4↙
    Thursday
    Friday
    Saturday
    Sunday
    error
     
    输入4，发现和第四个分支匹配，于是就执行第四个分支以及后面的所有分支。这显然不是我们想要的结果，我们希望只执行第四个分支，跳过后面的所有分支。
     
    为了避免这种情况，C语言还提供了一个关键字 break，专门用于跳出switch语句。
     
    switch 的分支语句一共有 n+1 种，而我们通常希望的都是选择其中的一个分支来执行，执行完后就结束整个 switch 语句，而继续执行 switch后面的语句，此时就可以通过在每个分支后加上 break 语句来实现了。如下：
    switch (表达式){
        case 常量表达式1: 语句1; break;
        case 常量表达式2: 语句2; break;
        ......
        case 常量表达式n: 语句n; break;
        default: 语句n+1; break;
    }
    加了这个 break 语句后，一旦“常量表达式 x”与“表达式”的值相等了，那么就执行“语句 x”，执行完毕后，由于有了 break 则直接跳出 switch 语句，继续执行 switch 语句后面的程序了，这样就可以避免执行不必要的语句。
     
    使用switch语句修改上面的代码：
    1. #include <stdio.h>
    2. int main(){
    3.     int a;
    4.     printf("Input integer number:");
    5.     scanf("%d",&a);
    6.     switch(a){
    7.         case 1: printf("Monday
"); break;
    8.         case 2: printf("Tuesday
"); break;
    9.         case 3: printf("Wednesday
"); break;
    10.         case 4: printf("Thursday
"); break;
    11.         case 5: printf("Friday
"); break;
    12.         case 6: printf("Saturday
"); break;
    13.         case 7: printf("Sunday
"); break;
    14.         default:printf("error
"); break;
    15.     }
    16.     return 0;
    17. }

    运行结果：
    Input integer number:4↙
    Thursday
    值得一提的是，由于default是最后一个分支，匹配后不会再执行其他分支，所以也可以不用break;语句。

    5.C语言条件运算符

    如果希望获得两个数中最大的一个，可以使用 if 语句，例如：
    1. if(a>b){
    2.     max = a;
    3. }else{
    4.     max = b;
    5. }

    不过，C语言提供了一种更加简单的方法，叫做条件运算符，语法格式为：
        表达式1 ? 表达式2 : 表达式3
     
    条件运算符是C语言中唯一的一个三目运算符，其求值规则为：如果表达式1的值为真，则以表达式2 的值作为整个条件表达式的值，否则以表达式3的值作为整个条件表达式的值。条件表达式通常用于赋值语句之中。
     
    上面的 if else 语句等价于：
    1. max = (a>b) ? a : b;
    该语句的语义是：如a>b为真，则把a赋予max，否则把b 赋予max。
    你可以认为条件运算符是一种简写的 if else，你完全可以用 if else 代替条件运算符。
    使用条件表达式时，还应注意以下几点：
    1) 条件运算符的优先级低于关系运算符和算术运算符，但高于赋值符。因此
    1. max=(a>b) ? a : b;
    可以去掉括号而写为
    1. max=a>b ? a : b;
     
    2) 条件运算符?和：是一对运算符，不能分开单独使用。
     
    3) 条件运算符的结合方向是自右至左。例如：
    1. a>b ? a : c>d ? c : d;
    应理解为：
    1. a>b ? a : ( c>d ? c : d );
    这也就是条件表达式嵌套的情形，即其中的表达式又是一个条件表达式。
     
    用条件表达式重新编程，输出两个数中的最大值：
    1. #include <stdio.h>
    2. int main(){
    3.     int a, b, max;
    4.     printf("Input two numbers:");
    5.     scanf("%d %d", &a, &b);
    6.     printf("max=%d
", a>b?a:b);
    7.     return 0;
    8. }

    运行结果：
    Input two numbers:23 45
    max=45

    6.C语言while语句

    在C语言中，共有三大常用的程序结构：
    1. 顺序结构：代码从前往后执行，没有任何“拐弯抹角”；
    2. 选择结构：也叫分支结构，重点要掌握 if else、switch 以及条件运算符；
    3. 循环结构：重复执行同一段代码。
     
    前面讲解了顺序结构和选择结构，本节开始讲解循环结构。所谓循环（Loop），就是重复地执行同一段代码，例如要计算 1+2+3+……+99+100 的值，就要重复进行99次加法运算。

    ①.while循环

     
    while循环的一般形式为：
        while(表达式){
            语句块
        }
    其中表达式称为循环条件，语句块称为循环体。
     
    while语句的意思是：先计算表达式的值，当值为真（非0）时， 执行循环体语句；执行完循环体语句，再次计算表达式的值，如果为真，继续执行循环体……这个过程会一直重复，直到表达式的值为假（0），就退出循环，执行后面的语句。其执行过程如下图所示：
     
     
    用while语句计算1加到100的值：
    1. #include <stdio.h>
    2. int main(void){
    3.     int i=1, sum=0;
    4.     while(i<=100){
    5.         sum+=i;
    6.         i++;
    7.     }
    8.     printf("%d
",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循环后面的代码。
     
    再看一个例子，统计从键盘输入的一行字符的个数：
    1. #include <stdio.h>
    2. int main(){
    3.     int n=0;
    4.     printf("Input a string:");
    5.     while(getchar()!='
') n++;
    6.     printf("Number of characters: %d
", n);
    7.     return 0;
    8. }

    运行结果：
    Input a string:c.biancheng.net↙
    Number of characters: 15
     
    本例程序中的循环条件为getchar()!=' '，其意义是，只要从键盘输入的字符不是回车就继续循环。循环体n++;完成对输入字符个数计数。

    ①.do-while循环

     
    除了while循环，在C语言中还有一种 do-while 循环。
     
    do-while循环的一般形式为：
    do{
        语句块
    }while(表达式);
     
    do-while循环与while循环的不同在于：它会先执行循环体，然后再判断表达式是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while 循环至少要执行一次循环体。其执行过程可用下图表示：
     
     
    用do-while计算1加到100的值：
    1. #include <stdio.h>
    2. int main(){
    3.     int i=1, sum=0;
    4.     do{
    5.         sum+=i;
    6.         i++;
    7.     }while(i<=100);
    8.     printf("%d
", sum);
    9.     return 0;
    10. }

    运行结果：
    5050
    注意 while(i<=100); 最后的分号;，这个必须要有。
    while循环和do-while各有特点，大家可以适当选择，实际编程中使用while循环较多。

    7.C语言for循环

    除了while循环，C语言中还有for循环，它的使用更加灵活，完全可以取代while循环。
     
    for循环的一般形式为：
    for(表达式1; 表达式2; 表达式3){
        语句块
    }
     
    它的执行过程如下：
    1) 先求解表达式1。
     
    2) 求解表达式2，若其值为真（非0），则执行循环体，否则结束循环。
     
    3) 执行完循环体，再求解表达式3。
     
    4) 重复执行步骤 2) 和 3)，直到循环结束。
     
    注意：表达式1仅在第一次循环时求解，以后都不会再执行，可以认为这是一个初始化语句。
     
    for循环的执行过程可用下图表示：
     
     
    用for循环来计算1加到100的值：
    1. #include <stdio.h>
    2. int main(){
    3.     int i, sum=0;
    4.     for(i=1; i<=100; i++){
    5.         sum+=i;
    6.     }
    7.     printf("%d
",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语句相当于：
    1. i=1;
    2. while(i<=100){
    3.     sum+=i;
    4.     i++;
    5. }
    由此我们可以总结出for循环的一般形式：
    for(循环变量赋初值; 循环条件; 循环变量增量){
        语句块
    }
    循环变量赋初值总是一个赋值语句，它用来给循环控制变量赋初值；循环条件是一个关系表达式，它决定什么时候退出循环；循环变量增量，定义循环控制变量每循环一次后按什么方式变化。这三个部分之间用分号;分开。

    ①.使用for语句应该注意

     
    1) for循环中的“表达式1（循环变量赋初值）”、“表达式2(循环条件)”和“表达式3（循环变量增量）”都是选择项，即可以缺省，但分号(;)不能缺省。
     
    2) 省略了“表达式1（循环变量赋初值）”，表示不对循环控制变量赋初值。
     
    3) 省略了“表达式2(循环条件)”，则不做其它处理时便成为死循环。例如：
    1. for(i=1; ; i++) sum=sum+i;

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

    所谓死循环，就是循环条件永远为真，循环会一直进行下去，永不结束。死循环对程序的危害很大，一定要避免。
    4) 省略了“表达式3(循环变量增量)”，则不对循环控制变量进行操作，这时可在语句体中加入修改循环控制变量的语句。例如：
    1. for( i=1; i<=100; ){
    2.     sum=sum+i;
    3.     i++;
    4. }

     
    5) 省略了“表达式1（循环变量赋初值）”和“表达式3（循环变量增量）”。例如：
    1. for( ; i<=100 ; ){
    2.     sum=sum+i;
    3.     i++;
    4. }

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

     
    6) 3个表达式都可以省略。例如：
        for( ; ; )  语句
    相当于：
        while(1)  语句
     
    7) 表达式1可以是设置循环变量的初值的赋值表达式，也可以是其他表达式。例如：
    1. for( sum=0; i<=100; i++ )  sum=sum+i;

     
    8) 表达式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;

     
    9) 表达式2一般是关系表达式或逻辑表达式，但也可是数值表达式或字符表达式，只要其值非零，就执行循环体。例如：
    1. for( i=0; (c=getchar())!='
'; i+=c );

    又如：
    1. for( ; (c=getchar())!='
' ; )
    2.     printf("%c",c);

     
    for循环也可以嵌套使用，例如：
    1. #include <stdio.h>
    2. int main(){
    3.     int i, j, k;
    4.     printf("i j k
");
    5.     for (i=0; i<3; i++)  // 循环①
    6.         for(j=0; j<3; j++)  // 循环②
    7.             for(k=0; k<3; k++)  // 循环③
    8.                 printf("%d %d %d
", i, j, k);
    9.     return 0;
    10. }

    8.C语言跳出循环

    使用while或for循环时，如果想提前结束循环，可以使用break或continue语句。

    ①.break语句

     
    在讲解 switch 语句时，我们使用到了break，用来跳出switch语句。
     
    当break语句用于 while、for 循环语句中时，会终止循环而执行循环语句后面的代码。break语句通常和 if 语句一起使用，即满足条件时便跳出循环。
     
    使用while循环计算1加到100的值：
    1. #include <stdio.h>
    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
", sum);
    10.     return 0;
    11. }

    运行结果：
    5050
     
    while循环条件为 1，是一个死循环。当执行到第100次循环的时候，计算完i++;后 i 的值为 101，此时 if 语句的条件 i> 100 成立，执行break;语句，结束循环。
     
    在多层循环中，一个break语句只向外跳一层。例如，输出一个4*4的整数矩阵：
    1. #include <stdio.h>
    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("
");
    12.         i++;
    13.         if(i>4) break;  // 跳出外层循环
    14.     }
    15.     return 0;
    16. }

    运行结果：
    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 条件语句一起使用，判断条件是否成立。
     
    来看一个例子：
    #include <stdio.h>
    int main(){
        char c;
        while(c!=13){  //回车符结束循环
            c=getch();
            if(c==0X34)  // 按下的是数字键4
                continue;  // 不执行printf语句便进行下次循环
            printf("%c", c);
        }
        printf(" ");
        return 0;
    }
    输入 123456789，只能显示12356789，4 没有显示。
     
    break与continue的对比：break 用来结束所有循环，循环语句不再有执行的机会；continue 用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。

    9.C语言循环总结

    除了 while 和 for 语句，在C语言中还有一个语句 goto，它也能构成循环。不过由于 goto 语句很容易造成代码混乱，维护和阅读困难，饱受诟病，不被推荐，而且 goto 循环完全可以被其他循环取代，所以后来的很多编程语言都取消了 goto 语句，我们也不再讲解。
    国内很多大学仍然讲解 goto 语句，但也仅仅是完成教材所设定的课程，goto 语句在实际开发中很难见到，笔者也没有使用过。

    ①.总结

     
    while和for 循环都可以用来处理同一个问题，一般可以互相代替。
     
    对于while和do-while循环，循环体中应包括使循环趋于结束的语句。
     
    用while和do-while循环时，循环变量初始化的操作应在while和do-while语句之前完成，而for语句可以在内部实现循环变量的初始化。
     
    for循环是最常用的循环，它的功能强大，可以代替其他循环。

    ②.几个例子

     
    用下面的公式求π：
     
     
    分析：首先，系数为正数的项的分母是4n-3(n为正数项的项数)，为负数的项的分母为4n-1(n为负数项的项数)，即分母的变化规律是1、3、5、7...的奇数数列，则第n项的分母为2n-1，第10000项的分母为2*10000-1。
    1. #include <stdio.h>
    2. #include <math.h>
    3. int main()
    4. {
    5.     double p=0,j=1;
    6.     int i;
    7.     for( i=1;i<10000;i++ )  //此处i为项数
    8.     {
    9.         j=pow(-1.0,i+1)/(2*i-1);  //pow(x,y)用来求x的y次幂
    10.         p+=j;
    11.         printf("%lf
",4*p);  //输出每一项的值
    12.     }
    13.     printf("%lf
",4*p);  //输出最终pi值
    14.     return 0;
    15. }

    由于输出结果较多，请大家自己运行代码。
  • 相关阅读:
    1451. Rearrange Words in a Sentence
    1450. Number of Students Doing Homework at a Given Time
    1452. People Whose List of Favorite Companies Is Not a Subset of Another List
    1447. Simplified Fractions
    1446. Consecutive Characters
    1448. Count Good Nodes in Binary Tree
    709. To Lower Case
    211. Add and Search Word
    918. Maximum Sum Circular Subarray
    lua 时间戳和时间互转
  • 原文地址：https://www.cnblogs.com/caizheng/p/6155209.html
Copyright © 2011-2022 走看看