精华内容
下载资源
问答
  • C语言程序的三种基本结构

    千次阅读 2017-02-26 17:54:00
    1、程序结构:在C语言程序中,一共有三种程序结构:顺序结构、选择结构(分支结构)、循环结构;  顺序结构:从头到尾一句接着一句执行下来,直到执行完最后一句;  选择结构:到某个节点后,会根据一次判断...

    1、程序结构:在C语言程序中,一共有三种程序结构:顺序结构、选择结构(分支结构)、循环结构;

      顺序结构:从头到尾一句接着一句的执行下来,直到执行完最后一句;

      选择结构:到某个节点后,会根据一次判断的结果来决定之后向哪一个分支方向执行;

      循环结构:循环结构有一个循环体,循环体里是一段代码。对于循环结构来说,关键在于根据判断的结果,来决定循环体执行多少次;

      注:在逻辑上有一种bool类型(也叫boolean类型,布尔类型),只有两个值,即真和假。C语言的判断表达式最终的值就是一个bool类型,这个判断表达式的bool值就决定了选择结构如何选择,循环结构如何循环;

    2、顺序结构:顺序结构很简单,一般我们遇到的除了选择结构和循环结构外,都是顺序结构;

    3、选择结构:C语言中常用的选择结构主要有以下两种:

      (1) if else:引入关键字:if  else  else if

        if (bool值)     // 如果bool值为真,则执行代码段1,否则执行代码段2

        {

          代码段1

        }

        else

        {

          代码段2

        }

        if (bool值1)    // 如果bool值1为真,则执行代码段1,否则判断bool值2是否为真

        {

          代码段1

        }

        else if (bool值2)  // 若bool值2为真则执行代码段2,否则直接执行代码段3

        {          // 开头的if和结尾的else都只能有一个,但是中间的else if可以有好多个

          代码段2

        }

        else

        {

          代码段3

        }

     1 #include <stdio.h>
     2 
     3 int main(void)
     4 {
     5     int a, b, max;
     6     
     7     a = 456;
     8     b = 45;
     9     
    10     if (a > b)            // 判断表示式
    11     {
    12         max = a;
    13         printf("true.\n");
    14     }
    15     else if (a == b)
    16     {
    17         max = a;
    18         printf("a == b.\n");
    19     }
    20     else
    21     {
    22         max = b;
    23         printf("false.\n");
    24     }
    25     
    26     printf("max = %d.\n", max);
    27     
    28     return 0;
    29 }

     

      (2) switch case:引入关键字:switch  case  break  default

        switch (变量)       // 执行到这一句时,变量的值是已知的

        {             // switch case语句执行时,会用该变量的值依次与各个case后的常数去对比,试图找到第一个匹配项找到匹配的项目后,

           case 常数1:       // 就去执行该case对应的代码段如果没找到则继续下一个case,直到default

             代码段1;        // 如果前面的case都未匹配,则default匹配。

             break;

           case 常数2:  

             代码段2;

             break;

           ……

           default:

             代码段n;

             break;

        }

        注:第一,case中必须是常数,而且必须是整形;

          第二,一般来说,每个case中代码段后都必须有一个break;

          第三,case之后一般都会有default,虽然语法上允许没有default,但是建议写代码时一定要写;

     1 // 结构化设计-选择结构示例代码 switch case演示
     2 #include <stdio.h>
     3 
     4 int main(void)
     5 {
     6     int num;
     7     
     8     num = 1;
     9     
    10     switch (num)
    11     {
    12         case 1:
    13             printf("a\n");
    14             break;
    15         case 2:
    16             printf("b\n");
    17             break;
    18         case 3:
    19             printf("c\n");
    20             break;
    21         case 4:
    22             printf("d\n");
    23             break;
    24         default:
    25             printf("-\n");
    26             break;
    27     }
    28     
    29     return 0;
    30 }

     

      (3) if else和switch case的区别:if else适合对比条件较复杂,但是分支比较少的情况,switch case适合那种对比条件简单,但是分支较多的情况;

        通常的做法是:在适合使用switch case的情况下会优先使用switch case,如果不适合则使用if else;

    4、循环结构:C语言中常用的循环结构主要有以下三种:

      (1) for:

        for (循环控制变量初始化; 循环终止条件; 循环控制变量增量)

        {

          循环体

        }

        循环执行步骤:第一,先进行循环控制变量初始化;

               第二,执行循环终止条件,如果判断结果为真,则进入第三步;如果为假则循环终止并退出;

               第三,执行循环体;

               第四,执行循环控制变量增量,转入第二步;

        注:for循环()中的三部分除了循环终止条件外,其他两部分都可以省略,但标准的for循环中,应该把循环控制变量的初始化,增量都放在()当中,并且在循环体中绝对不应该更改循环控制变量;

     1 // 计算1+2+3+····+10
     2 #include <stdio.h>
     3 
     4 int main(void)
     5 {
     6     int i, sum;
     7     
     8     printf("i = %d.\n", sum);
     9     
    10     for (i=0,sum=0; i<=10; i++)
    11     {
    12         sum += i;
    13     }
    14     printf("sum = %d.\n", sum);
    15     
    16     return 0;
    17 }

     

     

      (2) while:

        循环控制变量初始化

        while(循环终止条件)

        {

          循环体

          循环控制变量增量

        }

        循环执行步骤:第一,先进行循环控制变量初始化(在while之前);

               第二,判断循环终止条件,如果判断结果为真,则进入第三步;如果为假则不执行循环体;

               第三,执行循环体;

               第四,执行循环控制变量增量,转入第二步;

     1 // 计算100以内所有奇数的和
     2 #include <stdio.h>
     3 
     4 int main(void)
     5 {
     6     int i, sum;
     7     
     8     i = 1;
     9     sum = 0;
    10     
    11     while(i < 100)
    12     {
    13         printf("i = %d.\n", i);
    14         sum += i;
    15         i += 2;
    16     }
    17     
    18     printf("sum = %d.\n", sum);
    19     
    20     return 0;
    21 }

     

     

      (3) do while:

        循环控制变量初始化

        do

        {

          循环体

          循环控制变量增量

        }while (循环终止条件);

        循环执行步骤:第一,先进行循环控制变量初始化(在do while之前);

               第二,执行循环体;

               第三,执行循环控制变量增量;

               第四,判断循环终止条件,如果判断结果为真,则返回第二步;如果为假则直接退出循环;

     1 // 计算100以内所有奇数的和
     2 #include <stdio.h>
     3 
     4 int main(void)
     5 {
     6     int i, sum;
     7     
     8     i = 1;
     9     sum = 0;
    10     
    11     do
    12     {
    13         printf("i = %d.\n", i);
    14         sum += i;
    15         i += 2;
    16     }while(i < 100);
    17     
    18     printf("sum = %d.\n", sum);
    19     
    20     return 0;
    21 }

     

      (4) 总结:不管哪种循环结构,都不能缺少循环控制条件初始化,终止条件,循环控制变量增量,循环体这四部分;

           while循环是先判断后执行,do while循环是先执行后判断,等循环一次之后,其实都是一样的;

     (以上所述内容为学习朱老师的嵌入式课程后复习笔记所得,目的是自己复习巩固知识,同时把自己学到的知识分享出来。能力有限,水平一般,如有错误,欢迎指正,谢谢!)

    2017-02-26 17:52:18

    转载于:https://www.cnblogs.com/ARM-kang/p/6442949.html

    展开全文
  • C语言程序三种基本结构

    万次阅读 2018-01-03 19:27:19
    文章中介绍C语言程序执行过程中最基本的三种结构,包括有:顺序结构、分支结构、循环结构。理解和学习程序的执行过程,对于以后学习其他的编程语言,或者程序的调试,程序调Bug都有很好的帮助。 程序是什么? ...

    前言


    文章中介绍C语言程序执行过程中最基本的三种结构,包括有:顺序结构、分支结构、循环结构。理解和学习程序的执行过程,对于以后学习其他的编程语言,或者程序的调试,程序调Bug都有很好的帮助。

    程序是什么?
    所谓的程序,就是一系列遵循一定规则和思想并能够正确完成指定工作的代码(也成为指令序列)。
    其中,程序的一个部分是描述问题的每一个对象及它们之间的关系,这部分被成为数据结构(我认为程序设计中非常重要的一门课程)。
    另外的一个部分是对这些对象进行处理的规则,当然这个就是算法。牛X的人,都是数学好的人~~
    因此有这么一种说法:程序=数据结构+算法
    程序设计=数据结构+算法+程序设计方法+语言工具和环境

    顺序结构


    后面介绍的内容,基本上是基于C程序来介绍,通过实例和注释来解释知识点的重难点和用法。
    顺序:顾名思义,从上到下、从左到右、从小到大……程序中的顺序结构便是从程序的main()函数入口,一条一条的指令执行,知道遇到程序结束的指令结束程序。

    当然第一个程序必须是:“Hello world”

    顺序结构程序代码:

    //载入头文件 std 标准 io输入输出流 
    #include<stdio.h>
    
    /*
    程序的入口函数 mian()函数 其中()中参数可以省略 
    agrc参数表示是程序指令的个数 
    agrv指针类型数组保存的是每一条指令在内存中的地址 
    */ 
    int main(int agrc,char *agrv[]){
    
        //定义一个字符串数组 给s初始化的内容是 Hello world!
        char s[] = "Hello world!";
        //将需要输出的内容输出到console控制台 
        printf("%s",s);
        /*
        程序需要返回一个int类型的数据
        程序能正常终止 返回值为 0 异常终止 返回值 1 
        这里正常终止 设置为 0 
        */ 
        return 0;
    } 

    程序执行结果

    C Hello world

    整体看一下这个程序

    输出结果可以看到“Hello world!”我们希望输出的内容输出到屏幕上了,可以看到程序执行了0.4415s,最后返回的结果是0,和我们的预期一样。

    程序具体的每一句的代码的执行目的代码注释里面有详细解释。其中良好的程序编写人员都会有代码注释的习惯,方便别人阅读和自己回头的理解。这里注释的方式有两种,程序中均有体现。

    程序运行流程:从main()入口函数进入程序,按照顺序的执行方式,一句一句的执行,定义char类型的字符串s,输出s,返回return,程序结束。很好理解。

    分支结构


    分支结构中需要知道if、else、elseif、switch case的用法

    分支结构程序代码:

    //载入头文件 std 标准 io输入输出流 
    #include<stdio.h>
    
    /*
    程序的入口函数 mian()函数 其中()中参数可以省略 
    agrc参数表示是程序指令的个数 
    agrv指针类型数组保存的是每一条指令在内存中的地址 
    */ 
    int main(int agrc,char *agrv[]){
    
        /*
        顺序结构
        */ 
        //定义一个字符串数组 给s初始化的内容是 Hello world!
        char s[] = "Hello world!";
        //将需要输出的内容输出到console控制台 
        printf("%s\n",s);
    
        /*
        分支结构 
        */
        int n;
        scanf("%d",&n);
        //if分支语句 括号内部判断是不是真 若为真 执行if内的语句
        //分支语句可以没有else 但有else 一定要有一个if与之对应
        //这里的括号内部判断的是一个数字 C语言中非0的数字均为真  
        if(3)
            printf("1:\t这是一个真语句!\n") ;
    
        //if -else -elseif 
        //判断输入的n与0的关系并输出 
        if(n>0)
            printf("2:\t%d大于0\n",n);
        else if(n == 0)
            printf("2:\t%d等于0\n",n);
        else
            printf("2:\t%d小于0\n",n);
    
        //分支嵌套 switch case
        if(n>0)
            printf("3:\t%d大于0\n",n);
        else
        {
            if(n == 0)
                printf("3:\t%d等于0\n",n); 
            else{
                switch(n){
                    //若n的值是 -1的情况 
                    case -1:
                        printf("3:\t%d小于0\n",n);
                        break;
                    //若n的值是 -2的情况   
                    case -2:
                        printf("3:\t%d小于0\n",n);
                        break;
                    //其它情况 
                    default:
                        printf("3:\t%d小于0\n",n);
                        break;
                }
            } 
        } 
    
        /*
        程序需要返回一个int类型的数据
        程序能正常终止 返回值为 0 异常终止 返回值 1 
        这里正常终止 设置为 0 
        */ 
        return 0;
    } 

    程序执行的结果:

    分支结构执行结果

    说明3点:

    1. 变量的定义位置,C语言会将一个域中用的变量定义到所有程序指令的最前面,这里分支结构这块定义了一个n,程序能正常执行,和编译有关。
      用C编译器的情况: gcc text.c;
      用C++编译器的情况: g++ test.c 或者 g++ test.cpp 或者 g++ test.c (也就是用g++命令或者源文件后缀是cpp,则默认是用C++编译器)。
      因为C++中没有这个说法,所以用g++编译不会出现问题。
    2. switch中的break,break的作用:break语句通常用在循环语句和开关语句中。当break用于开关语句switch中时,可使程序跳出switch而执行switch以后的语句;如果没有break语句,则会从满足条件的地方(即与switch(表达式)括号中表达式匹配的case)开始执行,直到switch结构结束。
    3. 另外可以注意使用C语言中的唯一的三目运算符:
      max = ( x > y ) ? x : y ;
      代替了一下的代码,使用非常方便
      if(x > y)
      max = x;
      else
      max = y;

    循环结构


    循环结构一般会结合着分支结构一起使用,完成对问题的求解。

    循环结构程序代码:

    //载入头文件 std 标准 io输入输出流 
    #include<stdio.h>
    
    /*
    程序的入口函数 mian()函数 其中()中参数可以省略 
    agrc参数表示是程序指令的个数 
    agrv指针类型数组保存的是每一条指令在内存中的地址 
    */ 
    int main(int agrc,char *agrv[]){
    
        /*
        顺序结构
        */ 
        //定义一个字符串数组 给s初始化的内容是 Hello world!
        char s[] = "Hello world!";
        //将需要输出的内容输出到console控制台 
        printf("%s\n",s);
    
        /*
        分支结构 
        */
        int n;
        scanf("%d",&n);
        //if分支语句 括号内部判断是不是真 若为真 执行if内的语句
        //分支语句可以没有else 但有else 一定要有一个if与之对应
        //这里的括号内部判断的是一个数字 C语言中非0的数字均为真  
        if(3)
            printf("1:\t这是一个真语句!\n") ;
    
        //if -else -elseif 
        //判断输入的n与0的关系并输出 
        if(n>0)
            printf("2:\t%d大于0\n",n);
        else if(n == 0)
            printf("2:\t%d等于0\n",n);
        else
            printf("2:\t%d小于0\n",n);
    
        //分支嵌套 switch case
        if(n>0)
            printf("3:\t%d大于0\n",n);
        else
        {
            if(n == 0)
                printf("3:\t%d等于0\n",n); 
            else{
                switch(n){
                    //若n的值是 -1的情况 
                    case -1:
                        printf("3:\t%d小于0\n",n);
                        break;
                    //若n的值是 -2的情况   
                    case -2:
                        printf("3:\t%d小于0\n",n);
                        break;
                    //其它情况 
                    default:
                        printf("3:\t%d小于0\n",n);
                        break;
                }
            } 
        } 
        /*
        循环结构
        */ 
        int m;
        //只要输入的内容不是文件结尾符 可以一直输入
        //循环内部可以控制结束条件 
        while(scanf("%d",&m) != EOF){
            //break
            //如果m的值等于0 后面的语句也不执行 或者写为 m==0 
            //调出while循环 执行循环外部的程序指令 
            if(!m)
                break;
            int sum = 0;
            for(int i=0;i<m;i++){
                //计算 0~m-1的和 
                sum += i;
            }
            printf("0~%d的和是%d\n",m-1,sum);
            //continue
            //如果m的值不等于0 后面的语句不执行
            //while的头入口继续循环 
            if(m!=0)
                continue;
            //执行的结果中可以发现这里从未执行 思考一下 why? 
            printf("这里执行了吗?\n");
        } 
    
        /*
        程序需要返回一个int类型的数据
        程序能正常终止 返回值为 0 异常终止 返回值 1 
        这里正常终止 设置为 0 
        */ 
        return 0;
    } 

    程序执行结果:

    循环执行结果图示

    说明几点:

    1. for循环使用最多,一般情况可以表示任何循环,和while循环均是当型循环,先判断,后执行。do{}while属于直到型循环,先做循环再判断,程序用应用不多,程序中也没有体现。
    2. 自增,自减符,++a、–a、a++、a–;符号在前表示的是:先做自增或者自减运算后以运算后的数值进行接下来的程序执行,符号在后表示的是:以当前值进行程序执行,执行结束后做自增自减运算进行下次程序执行。(在程序中可以体现)
    3. for循环中循环语句可以是单个语句、空语句也可以是复合语句;三个表达式可以是任意类型,其中的分号”;”不能省略。

    自增自减程序代码:

    #include<stdio.h>
    
    int main(){
        int sum = 0;
        printf("符号在后自增:%d\n",sum++);
        printf("符号在前自增:%d\n",++sum);
        return 0;
    } 

    程序运行结果:
    程序运行结果

    结语


    有关C语言程序三种基本结构,顺序结构、分支结构、循环结构的主要内容和知识都已经在程序中有所体现。
    文章内容是博主手写,难免出现错误和瑕疵,有错误请指出,有问题请积极留言一起交流。

    展开全文
  • C语言的三种基本结构

    2021-04-24 15:39:20
    文章目录C程序的流程控制一、C程序的结构化二、C程序的三种基本结构1.顺序结构2.分支结构a.条件分支条件分支语法格式:条件分支使用注意事项b.开关分支开关分支语法结构:开关分支使用注意事项:2.循环结构1.for循环...

    C程序的流程控制



    一、C程序的结构化

    C程序是以顺序结构,分支结构,循环结构三种基本结构构建的,单入口单出口

    二、C程序的三种基本结构

    1.顺序结构

    顺序结构: CPU从上到下依次执行

    2.分支结构

    1.分支结构功能:实现多选一
    2.分支结构分两类:条件分支,开关分支

    a.条件分支

    条件分支语法格式:

     格式A:
     if(表达式A){ 		
     	语句1;
     }
    

    如果表达式A为真,那么就执行语句1;

     格式B:
     if(表达式A){
     	语句1;
     }else{
     	语句2;
     }
    

    如果表达式A为真,那么就执行语句1;否则执行语句2;

     格式C
     if(表达式A){
     	语句1;
     }else if(表达式B){
     	语句2;
     }
     ....
     else if(表达式N){
     	语句N;
     }
    

    如果表达式A为真,那么就执行语句1;如果表达式A不为真,那么执行表达式B;如果表达式B为真,那么就执行语句2;如果表达式B不为真,那么就依次向下判断

     格式D:
     if(表达式A){
     	语句1;
     }else if(表达式B){
    	语句2;
     }
     ...
     else if(表达式N){
     	语句N;
     }else{
     	语句M;
     }
    

    如果表达式A为真,那么就执行语句1;如果表达式A不为真,那么就执行表达式B,如果表达式B为真,那么就执行语句2;如果表达式B不为真,那么就依次向下判断,如果上面表达式都不成立那么就执行语句M。

    例如

    #include <stdio.h>
    #include <string.h>
    
    int main(void){
    	//定义并初始化字符串
    	char str1[]="hello";
    	char str2[]="china";
    	int len=0;
    
    	//形式A:if
    	if(strlen(str1)){
    		printf("str1的有效长度:%d\n",strlen(str1));
    	}
    	
    	//形式B:if...else
    	len=strlen(str2);
    	if(0 == len){
    		printf("str2为空字符串\n");
    	}else{
    		printf("str2字符串有效长度:%d\n",len);
    	}
    
    	//形式C:if...else if
    	len = compare(str1,str2);
    	if(len > 0){
    		printf("str1大于str2\n");
    	}else if(0 == len){
    		printf("str1等于str2\n");
    	}else if(len < 0){
    		printf("str1小于str2\n");
    	}
    	
    	//形式D:if...else if...esle
    	if(str1[0] != (*(str2+0)){
    		str1[0] = (*(str2+0));
    	}else if(str1[1] != (*(str1+1))){
    		str1[1] = (*(str2+1));
    	}else if(str1[2] != (*(str2+2))){
    		str1[2] = (*(str2+2));
    	}else if(str1[3] != (*(str2+3))){
    		str1[3] = (*(str2+3));
    	}else if(str1[4] != (*(str2+4))){
    		str1[4] = (*(str2+3));
    	}else{
    		printf("%s %s\n",str1,str2);
    	}
    	
    	return 0;
    }
    
    //定义字符串比较函数
    int compare(char *pstr1,char *pstr2){
    	while(*pstr1){
    		if(*pstr1 != *pstr2){
    			return *pstr1 - *pstr2;
    		}
    		pstr1++;
    		pstr2++;
    	}
    	return *pstr1 - *pstr2;
    }
    

    条件分支使用注意事项

    1.if和else的配对原则:else或者else if和最近的if配对
    2.如果语句只有一条{}是可以省略的

    b.开关分支

    开关分支语法结构:

     switch(控制表达式){
     	case 常表达式1:
     		语句1;
     		break;
     	case 常量表达式2:
     		语句2;
     		break;
     	...
     	case 常量表达式N:
     		语句N
     		break;
     	default:
     		语句M;
     		break; //可以省略
     	}
    

    控制表达式的计算结果和case对应的常量表达式数值相等,那么就会执行对应的语句,一旦遇到break,switch…case开关分支立刻结束,如果控制表达式和case对应的常量表达式都不相等,那么就会执行default对应的语句。

    例如

    #include <stdio.h>
    
    int main(void){
    	//100~90  A
    	//89~80   B
    	//79~70   C
    	//69~60   D
    	//其他 	  E
    	int a=0;
    	printf("请输入你的成绩:");
    	scanf("%d",&a);	
    
    	if(a < 0 && a > 100){
    		printf("成绩不合法\n");
    		return -1;
    	}
    	switch(a/10){
    		case 10:
    		case 9:
    			printf("成绩为A等\n");
    			break;
    		case 8:
    			printf("成绩为B等\n");
    			break;
    		case 7:
    			printf("成绩为C等\n");
    			break;
    		case 6:
    			printf("成绩为D等\n");
    			break;
    		default:
    			printf("成绩为E等\n");
    		}
    		
    	
    	return 0;
    }
    

    开关分支使用注意事项:

    1.控制表达式被当成一个整数处理(int),可以是字符,但是不能是浮点数和字符串
    2.常量表达式必须是常量,不允许有重复的分支case
    3.如果其中某个case对应的break没有添加,那么当这个case成立后,并且执行其对应的语句后会继续执行下一个case
    4.default关键字可以写在任意case前但是必须添加break
    5.分支语句case:或者default如果定义变量记得添加{},并且将来只能在对应的case使用
    6.gcc编译器对开关分支switch…case生成的代码要比条件分支if…else少,所以switch…case代码执行效率高

    2.循环结构

    循环结构的功能:将一组语句重复多次执行
    三种类型循环:for循环,while循环,do…while循环

    1.for循环

    for循环的语法格式:

      for(表达式A,表达式B,表达式C){
      		循环语句;
      }
    

    for循环语句的执行流程:
    步骤一:首先计算运行表达式A(只运行一次)
    步骤二:然后计算运行表达式B,
    如果表达式B的结果为真时,那么运行循环语句;
    如果表达式B的结果为假时,那么for循环结束退出;
    步骤三:如果表达式B为真,那么就运行循环语句,并且当循环语句运行完毕
    再接着计算运行表达式C,表达式C运行完毕,接着步骤二直到表达式B为假时

    例如

    #include <stdio.h>
    #include <string.h>
    int main(void){
    	char a[]="hello,world";
    	char b[]="hello,china";
    
    	//形式1
    	for(int i=0;i < strlen(b);i++){
    		if(*(a+i) != *(b+i)){
    			*(a+i) = *(b+i);
    		}
    	}
    	//打印输出字符串
    	printf("a=%s b=%s\n",a,b);
    
    	//形式2
    	//for循环的的死循环
    	for(;;){
    		printf("%s\n",b);
    	}
    	
    	//形式3
    	int i=0;
    	for(;i<10;i++){
    		printf("%d\n",i);
    	}
    
    	//形式4
    	for(int i=0;;i++){
    		if(i >= 10){
    			break;
    		}
    		printf("%s\n",b);
    	}
    	
    	//形式5
    	for(int i=0;i <10;){
    		if( 0 == (i%2)){
    			continue;
    		}
    		printf("%d\n",i);
    	}
    	return 0;
    }
    

    while循环

    while循环语法格式:

      while(循环控制表达式){
      	循环语句;
      }
    

    while循环语句执行流程:
    步骤一:首先执行循环控制表达式
    如果循环控制表达式为真,那么就执行循环语句
    如果循环控制表达式为假,while循环直接结束
    步骤二:当循环语句执行完毕,继续执行第一步骤

    如果while循环语句只有一条{}可以省略

    例如

    #include <stdio.h>
    
    int main(void){
    	int number=0;
    	int sum=0;
    
    	while(number++ <= 100){
    		sum += number;
    	}
    	printf("%d\n");
    	return 0;
    }
    

    do…while循环

    do…while循环语法格式:

      do{
      	循环语句;
      }while(循环控制表达式);
    

    do…while循环语句执行流程:
    步骤一:先执行循环语句
    步骤二:然后计算执行循环控制表达式
    如果为真,继续执行循环语句,后续依次重复
    如果为假,do…while循环结束
    do…while循环语句特点:至少执行一次

    切记while()后的分号不可省略

    例如

    #include <stdio.h>
    
    int main(void){
    	char a[5]={'A','B','D','E','F'};
    	int len=sizeof(a)/sizeof(a[0]);
    	int b=0;
    	do{
    		printf("%d\n",*(a+b));
    		b++;
    	}while(b < len);  //此分号不可省略
    	
    	return 0;
    }
    

    goto语句

    goto语句语法格式:

    	goto 标签;
    

    可以让cpu跳转到任何一条语句去执行,标签名就是指定要跳转的地方
    标签名根据标识符命名规则来定

    例如

    #include <stdio.h>
    typedef enum{
    	LABEL_FREE_ONE,
    	LABEL_FREE_TOW,
    	LABEL_FREE_THREE
    }label_t;
    
    int main(void){
    	//形式1:
    	int a[5]={1,2,3,4,5};
    	int len=sizeof(a)/sizeof(a[0]);
    	int i=0;
    lab:
    	printf("%d\n",a[i]);//打印输出数组的第i个元素
    	i++;
    	if(i <len){
    		goto lab;
    	}
    
    	//形式2
    	int number=0;
    	scanf("%d",&number); //输入非0表示分配失败
    						//输入0表示分配成功
    		
    	printf("分配第一块内存:");
    	if(0 != number){
    		printf("分配失败\n");
    		goto LABEL_ONE;
    	}
    	
    	printf("分配第二块内存\n");
    	if(0 != number){
    		printf("分配失败\n");
    		goto LABEL_TOW;
    	}
    	
    	printf("分配第三块内存\n");
    	if(0 != number){
    		printf("分配失败\n");
    		goto LABEL_THREE;
    	}
    
    	printf("三块内存分配成功\n");
    	return 0;
    	
    LABEL_FREE_THREE:
    	printf("释放第二块内存\n");
    LABEL_FREE_TOW:
    	printf("释放第一块内存\n");
    LABEL_FREE_ONE:
    	printf("释放完成,程序结束\n");
    	return number;
    }
    

    空语句

    空语句使用语法:

    	;
    

    仅仅包含一个;语句

    应用场景:

    用于实现一个空循环,延时
    延时的时间不明确

    例如

    #include <stdio.h>
    
    int main(void){
    	for(;;);
    
    	for(int 1=0;i <10000;i++);
    
    	while(1);
    
    	;
    	return 0;
    }
    

    切记:在while/for循环中的圆括号误写了;,意外的变成了空循环

    例如

    #include <stdio.h>
    
    int main(void){
    	//园括号后误写上;导致循环语句成为空语句
    	for(int i=0;i<10;i++);{
    		//报错,未定义,如果循环变量定义在循环体内,循环变量只能用于该循环
    		printf("%d\n",i);  
    	}
    	return 0;
    }
    

    C语言多维数组

    多维数组

    展开全文
  • c语言第4章 程序设计的三种基本结构第四章 程序设计的三种基本结构 第四章 程序设计的三种基本结构 前面章节介绍了程序设计中用到的一些基本要素(常量、变量、运算符、表达式等),它们是构成程序的基本成份。...

    c语言第4章 程序设计的三种基本结构

    第四章 程序设计的三种基本结构 第四章 程序设计的三种基本结构 前面章节介绍了程序设计中用到的一些基本要素(常量、变量、运算符、表达式等),它们是构成程序的基本成份。程序设计是为了完成某一项任务而编写的指令集合,它是人与计算机进行信息交流的工具。本章将介绍为编写简单的程序所必需的一些内容及程序设计的三类语句 。 4.1 C语句概述 任何一种程序设计语言都具有特定的语法规则和一定的表现形式。按照一定的格式和构成规则书写程序,不仅可以使程序设计人员和使用程序的人员易于理解,更重要的是把程序输入到计算机时,计算机能够充分识别,并且正确执行它。C程序是用C语句来书写的,C语句可以分为以下三类: 1.控制语句 控制语句完成一定的控制功能。C只有以下9种控制语句: (1) if ( ) ~else~ (条件语句) (2) for ( ) ~ (循环语句)   (3) while( ) ~ (循环语句) (4) do~while( ) (循环语句) (5) continue (结束本次循环语句) (6) break (终止执行switch或循环语句) (7) switch (多分支选择语句) (8) goto (转向语句) (9) return (从函数返回语句) 以上9种控制语句中的( )表示其中是一个条件,~表示内嵌语句。 2.表达式语句 表达式语句由表达式加上分号“;”组成。它包括三种基本语句。 (1)赋值语句 执行赋值语句就是计算表达式的值,并将其赋给左边的变量。 例如: z=x+y; i++; (2)函数调用语句 由一次函数调用加一个分号构成一个语句。 例如:clrscr(); (3)空语句 空语句是只有一个分号而没有表达式的语句。下面是一个空语句: ; 它只是形式上的语句,什么也不做。有时用来作被转向点,或循环语句中的循环体,表示循环体什么也不做。 3.复合语句 用“{ }”把一些语句括起来成为复合语句,也称为分程序。如: { z=a+b; t=z/100; cout< void main() { float r,r1,r2,r3; r1=10; r2=20; r3=30; r=1/(1/r1+1/r2+1/r3); cout< void main() { char c1,c2; cin>>c1; c2=c1+32; cout<0。 众所周知,一元二次方程的根为: x1=   x2= 可以将上面的分式分为两项: p= ,q= ,x1=p+q,x2=p-q 根据以上分析,画出N-S流程图如图4.2所示。 4.3选择结构程序设计 计算机在执行程序时,一般是按照程序中语句出现的先后次序逐句执行的,这就是顺序结构的程序。但是对于一些稍复杂的实际问题,常常要求依据某些条件来改变执行顺序,选择所要执行的语句,这种使计算机具有判断选择执行能力的语句称为选择语句,由选择语句构成的程序结构称为选

    展开全文
  • 返回 2020/1/23 多分支结构 注意 1 switch 关键字后面表达式可以是任意合法表达式 2 一定要用圆括号把 switch 后面 ( 表达式 ) 括起来否则会给出出错信息 3 所有 case 子句后所列常量表达式值都不能相同且...
  • 本节是学习C语言三种基本程序结构:顺序结构,选择结构,循环结构。     下载 图片格式课件(PPT课件转换为JPG图片)(以图片方式查看,可以在MP4上查看)   下载 Powerpoint课件 (在装有PowerPoint...
  • 程序的三种基本结构

    2020-06-21 17:25:40
    用这三种基本结构构成的的程序称为结构化程序。凡是能提供实现三种基本结构的语句语言,称为结构化语言。显然,C语言是结构化语言。 顺序结构 各操作步骤是顺序执行。顺序结构是最简单一种基本结构。 选择结构...
  • 第一章 C语言程序的基本控制结构 本章目录 4.1 程序的三种基本控制结构 4.2 顺序结构 顺序结构是最简单的一种程序结构它通常由说明语句表达式语句函数调用语句和输入输出语句组成是一种按程序的书写顺序依次执行的...
  • C语言三种结构

    2020-05-11 16:24:49
    C语言程序的基本结构 一.顺序结构 它是c语言最简单最基础的控制结构,即就是按照顺序从上到下依次执行。 例 #include<stdio.h> int main() { int x,y,z; scanf("%d %d",&x,&y); z=x+y; p
  • LOGO YOUR SITE HERE 第四章 顺序结构 4.1 三种基本结构 4.2 赋值语句 4.3 表达式语句和函数调用语句 4.4 复合语句和空语句 4.5 格式输入和输出函数 4.1 三种基本结构 三种结构流程图如下图所示顺序结构的程序是按...
  • 湖北汽车工业学院 C 语言程序设计考试试卷 3 课程编号 240006 考试形式 闭卷 考试日期 题号 一 二 三 四 五 六 七 八 九 十 总分 得分 阅卷人 核查人 一 填空题每小空 1 分共 20 分 1C语言程序的三种基本结构是 2一...
  • C语言是一种结构化编程语言结构化语言的基本元素是模块是程序的一部分每一个模块中都只有一个出口和一个入口 结构化程序由若干模块组成每个模块中包含若干个基本结构而每个基本结构中可以有若干条语句C语言三种...
  • 第4章 C语言程序结构 4.1 程序结构概述 4.2 顺序结构 4.3 选择结构 4.4 循环结构 4.5 无条件转向语句 4.1概述 任何一个结构化程序都可以由三种基本控制结构来表示 (1)顺序结构 顺序结构是最简单种基本结构它是按...
  • C语言的程序结构

    2017-05-14 22:13:50
    三种程序的基本结构: 1) 顺序结构 2) 选择结构 根据条件 p ,选择执行程序的某部分,但无论选择哪部分,程序均将汇集到同一个出口。 3) 循环结构  当型循环结构:当条件p成立(真)时,反复执行A操作,...
  • 今天主要学习了三种循环结构以及c语言语句书写规范格式。 通过if 语句,while 语句,for语句,switch语句,知道了如何编写一些循环的程序,也知道了如何利用程序解决一些实际问题。比如利用for 语句解决某案件。...
  • 学会white语句及for语句灵活运用 循环结构是程序设计三种基本结构之一其特点是在给定条件成立时反复执行某程序段直到条件不成立为止给定条件称为循环条件反复执行的程序段称为循环体利用循环结构进行程序设计一...
  • 程序流程角度来看,程序可以分为三种基本结构, 即顺序结构、分支结构、循环结构。 这三种基本结构可以组成所有各种复杂程序C语言提供了多种语句来实现这些程序结构。 本章介绍这些基本语句及其应用,使...
  • 循环结构是程序设计三种基本结构之一其特点是在给定条件成立时反复执行某程序段直到条件不成立为止给定条件称为循环条件反复执行的程序段称为循环体利用循环结构进行程序设计一方面降低了问题复杂性减少了程序...
  • PAGE PAGE 2 西北师范大学继续教育学院2007-2008学年 C语言 试卷A ...在C语言中单目运算符的结合方向(运算方向)是_唯一的一个三目运算符是_ =||&四个运算符的优先级次序由高到低是 _ C语言程序的三种基本结构是_结构_结
  • 顺序、选择和循环语句(程序的三种基本控制结构) 复合语句 1、在了解程序的三种基本控制结构之前,我们先了解以下什么是复合语句,即块语句。 2、与C语言及其他语言不同,Java语言的复合语句是以整个块区为单位的...
  • 21世纪高等学校精品规划教材 了解C++语言发展 了解面向对象程序设计方法的基本概念 掌握C++的程序结构 12.1 C++概述 12.1.1 C++语言发展 12.1.2 C++语言特点 C++是C语言的超集 C++是一面向对象的程序设计...
  • 循环结构是结构化程序设计基本的三种结构,但C语言中的循环不是无限制的,不允许出现死循环,它是有条件的,有限度的一种循环。 下面我们就C语言中几种基础的循环进行了解举例。 while语句 1.流程图: 2.语句格式...
  • C语言结构程序设计语言提供了功能丰富控制语句本章开始陆续介绍C语言的控制语句顺序结构选择结构和循环结构本章主要介绍三种结构化设计的基本概念格式输入输出函数printf)和scanf,字符输入输出函数putchar)和...
  • 1996年,计算机科学家Bohm和Jacopini证明了这样事实:“任何简单或复杂的程序都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。” 目录 顺序结构 选择结构 循环结构 break和continue语句 1、顺序...
  • C语言程序设计与数据结构 第十章 线 性 表 本章学习内容 线性表定义 线性表的基本运算 线性表的基本操作 线性表链式存储 13.1 线性表及其基本运算 13.1.1 线性表定义 线性表是最常用和最简单数据结构...
  • C语言结构程序设计语言提供了功能丰富控制语句本章开始陆续介绍C语言的控制语句顺序结构选择结构和循环结构本章主要介绍三种结构化设计的基本概念格式输入输出函数printf)和scanf,字符输入输出函数putchar)和...
  • 程序流程角度来看程序可以分为三种基本结构 1.顺序结构 2.选择结构 3.循环结构 C语言提供了多种语句来实现 这些程序机构;顺序结构;练练手;printf(Hello,world;一 printf)一般格式 printf(格式控制输出表列) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 583
精华内容 233
关键字:

c语言程序的三种基本结构是

c语言 订阅