2017.10.27 C语言精品集

最新推荐文章于 2024-10-02 23:12:55 发布

weixin_30471561

最新推荐文章于 2024-10-02 23:12:55 发布

阅读量236

点赞数

文章标签： c/c++ 数据结构与算法

原文链接：http://www.cnblogs.com/qichunlin/p/7745345.html

版权

第一章程序设计和C语言

1.1 什么是计算机程序？

@ ······ 所谓程序，就是一组计算机能识别和执行的指令。每一条指令使计算机执行特定的操作。
计算机的一切操作都是由程序控制的。所以计算机的本质是机器，程序和指令是计算机系统中最基本的概念

1.2 什么是计算机语言

@ ·· ····计算机和人都能识别的语言就是计算机语言

计算机语言经历的几个阶段：
（1）机器语言：计算机工作基于二进制，从根本上说，计算机只能识别和接受0和1组成的指令。这种计算机能直接识别和接受的二进制代码称为机器指令。机器的指令集合就是该计算机的机器语言；

（2）符号语言：例如用ADD代表“加” ，SUB代表“减”，LD代表“传送”
例： ADD A,B {执行A+B---A，将寄存器A中的数与寄存器B中的书相加，放到寄存器A中}

显然，计算机并不能直接识别和执行符号语言的指令，需要用一种称为汇编程序的软件吧符号语言的指令转换为机器指令。一条符号语言的指令对应转换为一条机器指令，因此符号语言又称为汇编语言。
不同型号的计算机的机器语言和汇编语言是互不通用的完全依赖于计算机的特性，是面向机器的语言，它贴近计算机，故称为计算机低级语言。

（3）高级语言：第一个计算机高级语言-----FORTRAN语言，这种语言功能很强，且不依赖机器，用它写出的程序对任何型号的计算机都适用，它与具体机器距离较远，故称为计算机高级语言。
用一种编译软件把高级语言写的程序（源程序 source program）转换为机器指令的程序（目标程序 object program），然后让计算机执行机器指令程序，得到结果。

高级语言经历了不用的发展阶段

（1）非结构化的语言    （2）结构化语言    （3）面向对象语言

####1.3  C语言的发展及特点
........发展：BCPL语言 -----B语言----C语言
........特点:
(1)语言简洁、紧凑、使用方便、灵活，C语言一共有37个关键字，9种控制语句，主要由小写字母表示
（2）运算符丰富。
（3）数据类型丰富
（4）语法限制不太严格
（5）具有结构化的控制语句
（6）允许直接访问物理地址，能进行位操作
（7）可移植性好
（8）生成目标代码质量高，执行效率高

1.4 最简单的c语言程序

#include <stdio.h>  //这是预编译处理指令
int main()         //定义主函数
{               //函数开始的标志
    printf("This is a C program.\n");//输出所指定的一行信息
    return 0;   //函数执行完毕时返回函数值0
}               //函数结束时的标志

程序分析：
····stdio.h 是系统提供的一个文件名，“standard input& output“的缩写，”.h“是头文件（header file）
····其中main是函数的名字，表示主函数，main前面的int表示此函数的是int类型，在执行主函数后会得到一个值其值为整型；
····return 0 的作用是：当main函数执行结束前将整数0作为函数值返回到调用函数处。
····每个C语言程序都必须有一个main函数。函数体由“{ }”括起来。
·····“\n”是换行符，在执行完输出语句后光标显示在下一行。

C语言注释有两种方式

（1）以“ // ”开始的单行注释
（2）以“ /**/ ”可以注释块
注意：若注释符号出现在输出语句的字符串中则作为其中的一部分
例如： print("//how old are you!")
输出是：//how old are you!

例：求两个整数之和

include<stdio.h>
int main()
{
    int a,b,sum;
    a=123;
    b=456;
    sum=a+b;
    printf("sum is %d\n",sum);
    return 0;
 } 
 第一个参数：sum is %d  的作用是输出格式字符串（sum is是用户希望输出的字符，%d是指定的输出格式表示十进制）
 第二个参数：sum表示要输出变量sum的值

### 例，求两个整数中的较大者

include<stdio.h>//编译预处理指令

int main()
{
int max(int x,int y); //对被调用函数max的声明
int a,b,c; //定义变量a，b，c
scanf("%d,%d",&a,&b);//输入变量a，b值
//&是地址符，&a的含义是变量a的地址

c=max(a,b);    
printf("max=%d\n",c);//输出c的值 
return 0;       //返回函数值为0

}
int max(int x,int y) //定义max函数，函数值为整形，形式参数x和y为整形
{
int z;
if(x>y)z=x;
else z=y;
return(z);
}
```

C语言程序的结构

（1）一个程序由一个或多个源程序（3各部分）组成；··预处理指令··全局声明···函数定义；
（2）函数是C程序的主要组成部分（一个C语言程序是由一个或多个函数组成，其中必须包含一个main函数且只能有一个main函数）；
（3）一个程序包含两个部分：【函数首部和函数体（声明部分和执行部分）】；
（4）程序总是从main函数开始执行的；
（5）每个数据声明和语句的最后必须有一个分号；
（6）程序应当包含注释；
（7）c语言本身不提供输入输出语句；

1.5 运行C程序的步骤和方法

（1）输入和编辑源程序；
（2）对源程序进行编译，得到的一个二进制目标文件（.obj）
（3）进行连接处理，与函数库链连接成一个整体
一次编译只能得到与一个源程序文件相对应的目标文件称为目标模块
（4）运行可执行文件
····运行可执行程序（.exe）

1.6 程序设计的任务

1.程序设计是指从确定任务到得到结果、写出文档的全过程
2.一般经历的阶段：
···问题分析······设计算法······编写程序·····对程序进行编辑、编译、连接······运行程序，得到结果
3.关键字的概念：
·····调试（debug）：发现和排除程序中的故障过程
·····程序测试：设计多组测试结果，检查程序对不同的数据的运行情况。加以修改漏洞
·····程序文档（说明书）：主要有程序名称、程序功能、运行环境、程序的装入和启动

第二章算法---程序的灵魂

1.一个程序主要包括以下两方面的信息：

····对数据的描述：在程序中，要指定用到哪些数据以及这些数据的类型和数据的组织形式，这就是数据结构。
····对操作的描述：即要求计算机进行操作的步骤，也就是算法。
数据是操作的对象，操作目的是对数据进行加工处理

算法+数据结构=程序

2.1 什么是算法?

计算机算法分为两大类别：数值运算算法和非数值运算算法.

2.2简单的算法举例

**例题1：求 “13579*11”的值 **

include<stdio.h>
int main()
{
    int i;
    int j;
    int sum=1;
    for(int i=1;i<=6;i++)
    {
        j=2*i-1;
        sum=sum*j;
    }
    printf("1*3*5*7*9*11 sum equals is %d\n",sum);
    return 0;
 }

@例题2：判定2000-2500年中的每一年是否为闰年

先分析闰年的条件：
（1）能被整除，但不能被100整除的年份都是闰年；
（2）能被400整除的年份是闰年；

例题3：求1-1/2+1/3-1/4+1/5-1/6.......1/99-1/100的值

@  用sign代表当前处理的项前面的数值符号，term代表当前项的值。sum是累加和，deno是当前项的分支。
S1:sign=1
S2：sum=1
S3：deno=2
S4：sign=（-1）*sign
S5：term=sign*（1/deno）
S6：sum=sum+term
S7：deno=deno+1
S8：若deno<=100返回S4；否则算法结束

2.3算法的特性

（1）有穷性
（2）确定性
（3）有零个或多个输入
（4）有一个或多个输出
（5）有效性
****

2.4 怎样表示一个算法

常用的方法有：
（1）自然语言：就是人们日常用的语言可以是汉语、英语等，一般不用自然语言来表示算法
（2）传统流程图：流程图是用一些图框形成图形来表示各种操作；
比如：菱形框的作用是对一个给定的条件进行判断；它有一个入口，两个出口。

（3）结构化流程图由三种基本结构组成
----【顺序结构】先执行A操作在执行B操作
-----【选择结构】又称为选取结构或分支结构，此结构中必定包含一个判断框
-----【循环结构】又称为重复结构，即反复执行某一个部分的操作（直到型until）&&（当型while）

￥直到型：作用是，先执行A框，然后判断给定的P2条件是否成立，如果P2条件不成立，则在执行A，然后对P2条件进行判断，如此反复

￥当型：作用是，当给定的p1条件成立时，执行A框，执行完A后，在判断P1条件是否成立，如果仍成立，在执行A框。

三种基本结构有以下共同特点：
【1】只有一个入口
【2】只有一个出口
【3】结构内的每一部分都会被执行到
【4】结构内不存在死循环
****
（4）用N-S结构化流程图表示算法
全部算法写在一个矩形框内，在该框内还可以包含其他从属于它的框，就是由一些基本的框组成的大框。
（N-S图如同一个多层的盒子，又称为盒图）
归纳起来可知：
一个结构化的算法是由一些基本结构顺序组成的；在基本结构之间不存在向前或向后的跳转，流的转移只存在于一个基本结构范围内
（5）用伪代码表示算法

第三章最简单的C程序结构-----顺序结构设计

@例题1：将华氏温度转化表示成摄氏度

#include<stdio.h> 
int main()
{
    float f;
    float c;
    scanf("%f",&f);
    c=(5.0/9.0)*(f-32.0);//c为浮点所以要加小数点
    printf("f=%f\n c=%f\n",f,c);
    return 0;
}

**例题2：/*计算存款信息，有1000元，想存一年，有三种方法可选**
（1）活期，年利率r1；
（2）一年定期，年利率为r2；
（3）存两次半年定期，年利率为r3.
请分别计算出一年后的的本息和

#include<stdio.h>
int main()
{
    float r1,r2,r3;
    float p0=1000;
    float p1;
    float r1=0.0036;
    
    float p2;
    float r2=0.0025;

    float p3;
    float r3=0.0198;
    
    p1=p0*(1+r1);
    p2=p0*(1+r2);
    p3=p0*(1+r3/2)*(1+r3/2);
    
    printf("p1=%f\n p2=%f\n p3=%f\n",p1,p2,p3);
    return 0;
 }

3.2 数据的表现形式及其运算

（1）常量包括以下几种：

···整型常量（例如.1000）；

···实行常量(例如.12.23)；

····字符常量包括------【普通字符】……{用单撇号括起来的一个字符，例如‘a’ 、‘b’，不能写成 ‘ab’ 字符常量只能是一个字符，不包括单撇号；；；存储的不是字母a、 b而是以其ASCii代码存储 a=97 } &&【转义字符】以‘’开头的字符序列。

转义字符	字符值	输出结果
'	一个单撇号(')	具有此八进制码的字符
"	一个双撇号（"）	输出此字符
?	一个问号（？）	输出此字符
\	一个反斜线（）	输出此字符
\a	警告（alert）	产生声音或视觉信号
\b	退格（backspace）	将当前位置后退一个字符
\f	换页（form feed）	将当前位置移到下一页的开头
\n	换行	将当前位置移到下一行的开头
\r	回车（carriage return）	将当前位置移到本行开头
\t	水平制表符	将当前位置移到下一个tab键
\v	垂直制表符	将当前位置移到下一个移到下一个垂直制表符对齐点

····【字符串常量】例如：“boy” “123”字符串常量是双撇号中的全部字符，不可以写成 ‘CHINA’

····【符号变量】用#defind指令，指定用一个符号名称代表一个变量。

例如：#define PI    3.1416     //注意行末没有分号
#define  PRICE 40   //

@注意：要区分符号常量和变量，不要把符号常量误认为变量。符号常量不占用内存，只是一个临时符号，在预编译后这个符号就不存在了，故不能对符号常量赋于新值。习惯上符号常量用大写字母表示。

（2）变量

    变量代表一个有名字、具有特定属性的一个存储单元。它用来存放变量的值数据。，变量必须先定义后使用，变量的值是可以改变的

（3）常变量

    例如：count int a=3；//表示a被定义为一个整形变量，指定值为3，且其值不能改变

注意：常变量与常量的异同是：常变量具有变量的基本属性：有类型，占存储空间，只是不允许改变其值。可以说常变量是有名字的不变量，而常量是没有名字的不变量

（4）标识符

    标识符就是一个对象名字，标识符的组成：字母、下划线、数字三种符号，且第一个字符必须是字母或下划线。

（5）数据类型

所谓类型就是对分配存储单元的安排，包括存储单元的长度（占多少字节）以及数据的存储形式。

    数据类型有：基本类型、枚举类型（enum）&空类型（void）、派生类型；
    基本类型包括：整型类型、浮点类型；
    整型类型包括：基本整型（int）、短整型（short int）、长整形（long int）、双长整型（long long int）、字符型（char）、布尔型（bool）；
    浮点类型：单精度浮点类型（float）、双精度浮点类型（double）、复数浮点型（float_complex,double_comple,long_comple）;
    派生类型：指针类型（*）、数组类型（[]）、结构体类型（struct）、函数类型

1./整型数据的要点：
···整型在存储单元中的存储方式是：用整数的补码形式存放；
···正数的补码是本身简称三码合一。
····求负数补码的方法：将此数的绝对值写成二进制形式，然后对其后面所有的二进位按位取反加1.
···sizeof是测量类型或变量长度的类型。
@整型变量符号的属性
| 类型 | 字节数|或
| :-------- | --------:|
| int（基本整型） | 2 | 4
| short（短整型） | 2 |
| unsigned int（无符号基本整型） | 2 | 4 |
| long | 4 | |
| unsigned long | 4 | |
| long long | 8 | |
| unsigned long long | 8 | |

注意：只有整型（包括字符型）数据可以加signed 或unsigned 修饰符，实型数据（实型数据分两类：单精度（float）和双精度（double）不能加。
整形常量和字符型常量不占用内存空间，其他占用。另外const定义的那种不是真正意义上的常量，要占用内存空间。

2/字符型数据
字符变量是用类型符char定义字符变量。例如：char='?'; //定义c卫子夫型变量并使初值为字符'?' '?' 的ASCII代码是63，系统把整数63赋给变量c
@注意：如果将一个负整数赋给有符号字符型变量是合法的，但他不代表一个字符，而作为一字节整型变量存储负整数。

signed char c= -6；

3./浮点型数据：
@浮点型数据是用来表示具有小数点的实数的，由于小数点位置可以浮动，所以实数的指数形式称为浮点数。
注意：C程序中的实型常量都是双精度浮点型常量
@实型数据的有关情况
| 类型 | 字节数 | 有效数字 |
| :-------- | --------:| :------: |
| float | 4 | 6 |
| double | 8 | 15 |
| long double | 8 | 15 |
| long double | 16 | 19 |

（6）运算符与表达式

1/.自增、自减运算符
++i      --i   //在使用之前，先使i的值加(减)1;
i++      --i   //在使用i 之前，使i的值加（减）1
例如：
i=3；
printf("%d\n",++i);    //输出i=4
huo
printf("%d\n",i++);    //输出i=3

注意：自增运算符和自减运算符只能用于变量，而不能用于常量或表达式。
可以利用强制类型转换运算符将一个表达式转换成所需类型
例如： 5++ 或（a+b）++都是不合法的

（7）强制类型转换运算符

    例如：
    （double） a   //将a转换为double类型
    （int）（x+y）      //将x+y的值转换成int类型
    （float）（5%3）   //将5%3的值转换成float型

（8）C运算符

（1）算术运算符（+ - * / % ++ --）
（2）关系运算符（> < >= == <= !=）
（3）逻辑运算符（！ && || ）
（4）位运算（<< >> ~ | ^ &
（5）赋值运算符（=及其扩展赋值运算符）
（6）条件运算符（？：）
（7）逗号运算符（，）
（8）指针运算符（* &）
（9）求字节数运算符（sizeof）
（10）强制类型转换运算符（（类型））
（11）成员运算符（. ->）
（12）下标运算符（[]）
****

3.3 C语句

@（1）一个函数包含声明部分和执行部分。执行部分是由语句组成的。
c语句有控制语句、函数调用语句、表达式语句、空语句。

注意：表达式语句由一个表达式加一个分号构成，

    例如：
    a=3      //是一个赋值表达式
    a=3；    //是一个赋值语句

注意：空语句是一个“；”

；       //它的作用可以用来作为流程的转向点，也可以用来作为循环语句中方循环体

（2）最近基本的语句----赋值语句
最常用的语句是：赋值语句和输入输出语句。其中最基本的是----赋值语句
以后凡在程序中要用到数学函数库中的函数，都应当包含“math.h”文件
@·
例题：给出三角形的三边长，求三角形面积

#include<stdio.h>
#include<math.h>
int main()
{
    double a,b,c,s,area;  //定义各变量，均为double型 
    a=3.67;
    b=5.43;
    c=6.21;
    s=(a+b+c);
    area=sqrt(s*(s-a)*(s-b)*(s-c));
    printf("a=%f\t b=%f\t c=%f\t",a,b,c);
    printf("area=%f\n",area);
    return 0;
 }

（2）赋值过程中的类型转换
转化规则：
（1）将浮点型数据（包括单双精度）赋给整型变量时，先对浮点数取整，即舍弃小数部分，然后赋予整形变量；
（2）将整形变量赋给单双精度时，数值不变，但以浮点数形式存储在变量中；
（3）字符型数据赋给整型变量时，将字符的ASCII代码赋给整型变量

例如：   i=‘A’    //已定义i为整型变量   A的ASCII代码为65，因此i=65

3.4数据的输入和输出

例题：/求ax^2+bx+c=0方程的跟。a，b，c由键盘输入，设b^2-4ac>=0

#include<stdio.h>
#include<math.h>
int main()
{
    double a,b,c,disc,x1,x2,p,q;
    scanf("%lf%lf%lf",&a,&b,&c);    //%lf 表示双精度型实数 。&a表示变量a在内存中的地址
    disc=b*b-4*a*c;
    p=-b/(2.0*a);
    q=sqrt(disc)/(2.0*a);
    x1=p+q;
    x2=p-q;
    printf("x1=%7.2f\n x2=%7.2f\n",x1,x2);
    return 0;
 }

（1）标准输入输出函数：
····putchar 输出字符
···getchar 输入字符
····printf格式输出
····scanf格式输入
····puts 输出字符串
···gets输入字符串
（2）print函数输出数据：
print函数的一般格式：printf（格式控制，输出表列）
（3）格式字符：
【 d 格式符】用来输出一个有符号的十进制
【 c 格式符】用来输出一个字符
【 s 格式符】用来输出一个字符串
【 f 格式符】用来输出实数;

    ···指定数据宽度和小数位数，用%m.nf
例如：%7.2f     //格式指定输出的数据占7列，其中包括2位小数
    ···输出的数据向左对齐，用%-m.nf
例如：printf("%-25.15f,%25.15f\n",a,a);//第一次输出a的值向左端靠，右端空五列。第二次输出a时结果向右对齐左端空五列

【e格式符】用指数的形式输出实数

（如果不指定的话会自动分配小数位数为6位，指数部分占5位）
printf("%e",123,456);
输出如下：1.234560 e+0002
输出实数共占13列

（4）用scanf函数输入数据：

···scanf函数的一般格式：scanf(格式控制，地址表列)

（5）字符数据的输入输出：

（1）用putchar函数输出一个字符
·····一般形式为：putchar（c）
换行：putchar（'\n')
例子：//先后输出BOY三个字符
#include<stdio.h>
int main()
{
    char a='B',b='O',c='Y';
    putchar(a);
    putchar(b);
    putchar(c);
    putchar('\n');
    return 0;
 } 

(2)用getchar函数输入一个字符
····它只能接受终端键盘输入的一个字符。想输入多个的话需要多个getchar；

例题：//从键盘输入三个字符BOY，然后把他们输出到屏幕。 
#include<stdio.h>
int main()
{
    char a,b,c;
    a=getchar();
    b=getchar();
    c=getchar();
    putchar(a);
    putchar(b);
    putchar(c);
    putchar('\n');
    return 0;
 } 

优化之后的：
#include<stdio.h>
int main()
{
    putchar(getchar());//将接收到的字符输出
    putchar(getchar());
    putchar(getchar());
    putchar(getchar());
    putchar('\n');    //换行
    return 0;
}

//书上例题83页
 
#include<stdio.h>
int main()
{
    char c1,c2;
    c1=97;
    c2=98;
    printf("c1=%c,c2=%c\n",c1,c2);
    printf("c1=%d,c2=%d\n",c1,c2);
    return 0;
 } 

第一问：c1=a,c2=b      c1=97,c2=98

 
#include<stdio.h>
int main()
{
    char c1,c2;
    c1=197;
    c2=198;
    printf("c1=%c,c2=%c\n",c1,c2);
    printf("c1=%d,c2=%d\n",c1,c2);
    return 0;
 } 
第二问：c1=?,c2=?    c1=97,c2=98


#include<stdio.h>
int main()
{
    int c1,c2;
    c1=97;
    c2=98;
    printf("c1=%c,c2=%c\n",c1,c2);
    printf("c1=%d,c2=%d\n",c1,c2);
    return 0;
 } 
第三问：c1=a,c2=b      c1=97,c2=98

第四章选择结构程序设计

（1）选择结构与条件判断：
@C语言有两种选择语句：#if语句用来实现两个分支的选择结构 #switch语句用来实现多分支的选择结构。

例题：//求方程的根问题
#include<stdio.h>
int main()
{
    double a,b,cc,disc,x1,x2,p,q;
    scanf("%lf%lf%lf",&a,&b,&c);
    disc=b*b-4*a*c;
    if(disc<0)
        printf("This equation hasn't real root\n");
    else
    {
        p=-b(2.0*a);
        q=sqrt(disc)/(2.0*a);
        x1=p+q;
        x2=p-q;
        printf("real root:\n x1=%7.2f\n x2=%7.2f\n",x1,x2);
    }
    return 0;
}

用if'语句实现选择分支

例题：实现两个变量换值得办法
#include<stdio.h>
int main()
{
    float a,b,t;
    if(a>b)
    {
        t=a;
        a=b;
        b=t;
    }
    printf("%5.2f,%5.2f\n",a,b);
    return 0;
}

例题：输入abc三个数，要求由小到大的顺序输出
#include<stdio.h>
int main()
{
    float a,b,t;
    scanf("%ld%ld%ld",&a,&b,&c);
    if(a>b)
    {
        t=a;
        a=b;
        b=t;
    }
    if(a>c)
    {
        t=b;
        b=c;
        c=t;
    }
    printf("%5.2f,%5.2f,%5.2f\n",a,b,c);
    return 0;
}

(2)关系运算符和关系表达式

@关系运算符及其优先次序
···· <
···· <=
···· >
····>=

····>==
····>!=

例如：(关系运算符的优先级低于算术运算符)
c>a+b   等效于c>(a+b)
a>b==c  等效于(a>b)==c
a==b<c  等效于a==(b<c)
a=b>c   等效于a=(b>c)

（3）逻辑运算符和逻辑表达式

@逻辑运算符及其优先次序
!(非) ······&&（与）········||（或）··
（高）！（非）·············非算术运算符·········· 关系运算符··········· &&和||·······赋值运算符（低）【从高到低优先级】
有三种逻辑运算符：与（AND）、或（OR ）、非（NOT）

&&      逻辑与     a&&b     如果a和b都为真，则结果为真，否则为假
||      逻辑或     a||b    如果ab有一个以上是真，则结果为真，二者为假结果为假
！       逻辑非       ！a       如果a为假，则！a为真

逻辑型变量：定义逻辑变量用类型符 "_Bool"

float score;
scanf("%f",&score);
_Bool a,b;          //a、b被定义为逻辑型变量
a=score>=60;
b=score<=69;
if(a&&b)
printf("The grade isC\n");    //如果a、b为真，输出分数等级为C；

（4）条件运算符和条件表达式

例如: max=(a>b)?a:b;    //a:b是一个条件表达式；“？”是一个条件运算符

或者写成这样：max=a>b?a:b    //因为条件运算符优先级别比关系运算符和算术运算符都低。

解释语句：如果（a>b）为真则条件表达式的值等于a   否则取b

条件运算符由两个符号（？：）组成，必须一起使用。要求有三个操作对象，称为三元运算符。唯一的一个；表达式的一般形式为：表达式1？表达式2：表达式3

例题：//输入一个字符，判别他是否为大写字母，如果是，将它转化为小写字母；如果不是，不转换。然后输出字符

#include<stdio.h>
int main()
{
    char ch;
    scanf("%c\n",&ch);
    ch=(ch>='A' ch<='Z')?(ch+32):ch;
    printf("%c\n",ch);
    return 0;
}

（5）选择结构的嵌套

@在if语句中包含一个或多个if语句称为if语句的嵌套；else总是与他上面的最近的未配对的if配对
****

（6）用switch语句实现多分支选择结构

例题：//要求按照考试的等级输出百分制分数段
 
#include<stdio.h>
int main()
{
    char score;
    scanf("%c",&score);
    switch(score)     //这里不用加分号，加了的话会显示无法匹配对象 
    {
        case 'A':
        printf("A的分数段在85分以上\n");
        break;
        
        case 'B':
        printf("B的分数段在70~84分\n");
        break;
        
        case 'C' :
        printf("C的分数段在60~69分\n");
        break;
        
        case 'D':
        printf("D的分数段在60分以下\n");
        break;
        
        default:
        printf("enter date error\n");
        }
        return 0;   
 }

注意：每个case后面的语句中，最后都有一个break语句，它的作用是使流程转到switch语句的末尾（即花括号处）
****

例题：//对两个整数进行运算，如果输入a或A，就调用action1函数，进行两个数相加运算，如果输入B、b就调用action2函数 
#include<stdio.h>
int main()
{
    void action1(int,int),action2(int,int);  //先定义action1和action2函数 
    char ch;
    int a=15,b=23;
    ch=getchar();
    switch(ch)
    {
    case 'A':
    case 'a':
        action1(a,b);   //调用action1函数执行A操作 
        break;
    case 'B':
    case 'b':
        action2(a,b);  //调用action2函数，执行B操作 
        break;
        //.
        //.
        //.
        //. 
    default:
        putchar('\a');//如果输入其他字符，发出警告 alert
        
    }
    return 0;
 }
 
 void action1(int x,int y)   //执行加法的函数 
 {
    printf("x+y=%d\n",x+y);  
  } 
  void action2(int x,int y) //执行乘法的函数 
  {
    printf("x*y=%d\n",x*y);
  }

（7）选择结构程序综合案例

例题 1 ：//写一程序 ，判断某一年是否为闰年？
//判断闰年单位条件：1.year%4==0并且不能被100整除    2.能被400整除 满足以上条件就是闰年 

#include<stdio.h> 
int main()
{
    int year;
    int leap;
    printf("enter year:");
    scanf("%d",&year);
    if(year%4==0)
    {
        if(year%100==0)
        {
            if(year%400==0)
                leap=1;
            else
                leap=0;
        } 
        else 
            leap=0;
        if(leap)
            printf("%d is \n",year);
        else
            printf("%d is not",year);
            return 0;
    }
}

例题 2：改为逻辑变量判断闰年
//用逻辑变量和逻辑常量true和false。把leap定义为逻辑变量，它的值只能是true（即1）或false（即0）之一。

#include<stdio.h>
#include<stdbool.h>   //标准逻辑函数 （ std  bool） 
//第一二行改为【#include<iostream>】 
int main()
{
    int year;
    bool leap;          //定义leap逻辑变量 
    scanf("%d",&year);
    if(year%4==0)
    {
        if(year%100==0)
        {
            if(year%400==0)
            leap=true;
            else
            leap=false; 
        }
        else
        leap=true; 
    }
    else 
    leap=false;
    
    if(leap==true)    //检查leap的值是否为true 
    printf("%d is",year);
    else
    printf("%d is not",year);
    printf(" a leap year.\n");
    return 0;
 }

@······

例题：//求ax^2+bx+c=0的方程的解


/*
解题思路：
1.判断a=0，不是二元方程                                      （电脑键盘的根号操作方法：ALT+41420（右边小键盘）） 
2.b^2-4ac=0,有两个相等的根
3.b^2-4ac>0,有两个不相等的根
4.b^2-4ac<0,有两个共轭复根。应当以p+qi和p-qi的形式输出复根。其中p=-b/2a，q=（√b^2-4ac）/2a 
*/ 
 
#include<stdio.h>
#include<math.h>
int main()
{
    double a,c,b,disc,x1,x2,realpart,imagpart;  //定义变量 
    scanf("%lf,%ld,%ld",&a,&b,&c);    //输入三个数据 传送给abc 
    printf("The equation");
    if(fabs(a)<=1e-6)    //这里是数字“1”，不是英文“l ” 
    //fabs是求浮点数的绝对值;1e-6表示：1*10^(-6)次方也就是0.000001
    
        printf(" is not a quadratic\n"); 
    else
    {
        disc=b*b-4*a*c;
        if(fabs(disc)<=1e-6)
            printf(" has two equal roots:%8.4f\n",-b/(2*a));
        else
        if(disc>1e-6)
        {
            x1=(-b+sqrt(disc)/(2*a));
            x2=(-b-sqrt(disc)/(2*a));
            printf(" has distinct real roots:%8.4f and %8.4f\n",x1,x2);   //不一样的实数根 
        }
        else
        {
            realpart=-b*(2*a);   //realpart 是复根的实部 
            imagpart=sqrt(-disc)/(2*a);   //复根的虚部 
            printf(" has complex roots:\n"); 
            printf("%8.4f+%8.4f i\n",realpart,imagpart);  //输出一个复数 
            printf("%8.4f-%8.4f i\n",realpart,imagpart);   //输出另一个复数 
        }
    }
    return 0;
 }

第五章循环结构程序设计

（1）用while语句实现循环

···while一般形式：   while（表达式）语句
···可简单的记为：只要当循环条件表达式为真【给定的条件成立】，就执行循环体语句
···while的循环特点：先判断条件表达式，后执行循环体语句

例题：//计算“1+2+3+4......+100”的和

#include<stdio.h>
int main()
{
    int i=1,sum=0;
    while(i<=100)
    {
        sum=sum+i;
        i++;
    }
    printf("sum is %d\n",sum);
    return 0;
 } 
注意：在循环体中应该有使i增值以最终导致i>100的语句，今用i++l来处理。否则i的值始终不变 ，循环永远不结束。

（2）用do...while语句实现循环
语句的特点是：先无条件地执行循环体，然后到判断循环条件是否成立
while一般形式是：
do
语句 //循环体
while（表达式）

int i=1;      //设变量i的初值为1
do            //循环结构开始
{
    printf("%d",i++);  //循环体，输出i的值，然后使i+1
    }
    while(i<=100);  //当i小于或等于100时，继续执行循环体
    
    //结构是输出1~100个整数

换一种方式

#include<stdio.h> 
int main()
{
    int i=1;
    int sum=0;
    do{
        sum=sum+i;
        i++;
    }while(i<=100);
    printf("sum=%d\n",sum);
    return 0;
}
//do while的语句结构可以转换成while结构

比较

//while和do ...while的循环比较
/*
总结：while 先判断条件，满足的话继续执行循环体 （一次也不执行循环体） 
    do.... while 先执行循环条件，在进行循环后的条件判断 （至少执行一次循环体） 
    
    
*/ 
#include<stdio.h>
int main()
{
    int i;
    int sum=0;
    printf("please enter i,i=?");
    scanf("%d",&i);
    while(i<=10)
    {
        sum=sum+i;
        i++;
    }
    printf("sum=%d\n",sum);
    return 0;
}

第一次： 
输入 1
输出：sum=55 

第二次：
输入11
输出：sum=0 

#include<stdio.h>
int main()
{
    int i;
    int sun=0;
    printf("please enter i,i=?");
    scanf("%d\n",sum);
    do      //做/执行 
    {
        sum=sum+i;
        i++;
    }while(i<=10)
    printf("sum=%d\n",sum);
    return 0;
 } 
 
第一次：
输入：1
输出：sum=55

输入：11
输出：sum=11

（3）用for语句实现循环

for语句的一般形式：

for（表达式1；表达式2；表达式3）  语句     //for（循环变量初值；循环条件；循环变量增值）   语句
换成while语句
表达式1；
while 表达式2{
    语句
    表达式3
}   
注意：二者无条件等价

【三个表达式的作用：
表达式1：设置初始条件，只执行一次，只可以为零个、一个或多个变量设置初值
表达式2：是循环条件，用来判定是否继续循环。在每次执行循环体前先执行此表达式，决定是否继续
表达式3：作为循环调整，一般是变量的增值】

for三个表达式都可以省略但是分号不可以省略

···for(;i<=100;i++) sum=sum+i;    //等效于 i=1;  for(;i<=100;i++) sum=sum+i;  //作用仍然不变。
···for(i=1;;i++) sum=sum+i;      //等效于 i=1；while(1);{ sum=sum+i  i++; }  //此时循环无休止的下去。
···for(i=1;i<=100;) { sum=sum+i; i++; } //作用仍然不变 ，不可缺少自增条件
···for(;;) printf("%d\n",i);

（4）循环的嵌套
一个循环体内又包含另一个完整的循环结构，称为循环的嵌套
（5）改变循环的执行状态
@····用break语句提前终止循环，继续执行循环体下面的语句

例题：//在全系1000个学生中，征集慈善募捐，当总数达到10万元时就结束，统计此时捐款人数，以及平均每人捐款数目

#include<stdio.h>
#define SUM 100000
int main()
{
    float total;
    float amount;
    float aver;
    int i;
    for(i=1,total=0;i<=1000;i++)
    {
        printf("Please Enter Amount Money:");
        scanf("%f",&amount);
        total=amount+total;
        if(total>=SUM)       //这里不能加一个分号不然至执行一次。 
        break;
    }
        aver=total/i;
        printf("人数为:%d\n 总金额为:%f\n",i,aver);
    return 0;
 } 
// 注意：break语句只能用于循环语句和switch语句中，而不能单独使用。

@·····用continue语句可以提前结束本次循环,而接着执行下次循环。不会跳出整个循环。

    #include<stdio.h>
    int main()
    {
        int n;
        for(int n=100;n<=200;n++)
        {
            if(n%3==0)
            continue;
            printf("%d\n",n);
        }
        return 0;
    }

（6）break语句和continue语句的区别

continue语句只结束本次循环，而不是终止整个循环的执行。而break语句则是结束整个循环过程，不再判断执行循环的条件是否成立。

 `include<stdio.h>
int main()
{
    int i,j,n=0;
    for(i=1;i<=4;i++)
        for(j=1;j<=5;n++)
        {
            if(n%5==0)
            printf("\n");
            printf("%d\t",i*j);
        }
        printf("\n");
        return 0;
 }

转载于:https://www.cnblogs.com/qichunlin/p/7745345.html