第一章
1.1 什么是计算机程序
指令：可以被计算机理解并执行的基本操作命令
程序：一组计算机能识别和执行的指令。一个特定的指令序列用来完成一点过的功能。
软件：与计算机系统操作有关的的计算机程序、规程、规则，以及可能有的文件、文档及数据。
指令构成程序，程序构成软件。
1.2 什么是计算机语言
发展历程：
机器语言：计算机能够直接识别和接收的二进制0,1代码称为机器指令。机器指令的集合就是该计算机的机器语言。
特点：难学、难记、难检查、难修改、难以推广使用。依赖具体机器难以移植。
汇编语言（低级语言）：机器语言的符号化。用英文字母和数字表示指令的符号语言。
特点：先比机器语言简单好记，但仍然难以普及。
高级语言：
非结构化的语言（基于过程）：BASIC/FORTRAN/ALGOL
结构化语言（基于过程）：C语言/QBASIC/FORTRAN 77
面向对象的语言：C++/C#/Visual Basic/Java
1.3 C语言的发展及其特点
来源于B语言
最初是为UNIX提供一种工作语言
特点：
1.语言简洁紧凑、灵活方便
2.运算符丰富
3.数据类型丰富
4.具有结构化的控制语句
5.语法限制不太严格，程序设计自由度大
6.C语言允许直接访问物理地址，能进行位操作，能实现汇编语言的大部分功能。可以直接对硬件进行操作
7.可移植性好
8.生成目标代码质量高，程序执行效率高
1.4 最简单的C语言程序
示例：1.1
#include<stdio.h> （StanDard Input and Output header file）
int main() // 定义主函数
{
printf("This is a C program. \n"); （\n 换行符）
return 0;
}
---------------------------------------------------------------------------------------------------------------------------------
1.2求两个整数之和
#include<stdio.h>
int main()
{
int a, b, sum; //声明，定义a，b，sum为整型变量
a = 123;
b = 456;
sum = a + b;
printf("sum is %d\n", sum); //以十进制整数(%d)输出sum
return 0;
}
1.3求两个整数中的较大者
#include<stdio.h>
int main()
{
int max(int x, int y);
int a, b, c;
scanf("%d,%d", &a, &b); //&a变量a的地址
c = max(a, b);
printf("max=%d\n", c);
return 0;
}
//求两个整数中的较大者的max函数
int max(int x, int y) //定义max函数，函数值为整型，形式参数x和y为整型
{
int z; //声明并定义变量z为整型
if (x > y)z = x;
else z = y;
return(z); //将z的值作为max函数值，返回到调用max函数的位置
}
1.4.2 C语言程序的结构
1.一个程序由一个或多个源程序文件组成，源程序文件包含三个部分
1.1预处理指令
#include<stdio.h>
1.2全局声明
int a,b,sun;
1.3函数的定义
第二章
2.函数是C程序的主要组成部分
3.一个函数包括两个部分
3.1函数首部
int max （ int x , int , y ）
函数类型 函数名 函数参数类型 函数参数名 函数参数类型 函数参数名
（函数没有参数时，可以用int main(void)或int main()）
3.2函数体
3.2.1声明部分：定义用到的变量
3.2.2执行部分：由若干语句组成，指定在函数中所进行的操作
4.程序总是从main函数开始执行的（与位置无关）
5.程序中要求计算机完成的操作是由函数中的C语言完成的
6.在数据声明和语句的最后必须有一个分号
7.C语言本身不提供输入输出语句
scanf：输入语句
printf：输出语句
8.程序中应当包含注释
1.5运行C程序的步骤和方法
（1）上机输入和编辑源程序
（2）对源程序进行编译
（3）进行连接处理
（4）运行可执行程序
1.6程序设计的任务
（1）问题分析
（2）设计算法
（3）编写程序
（4）对源程序进行编辑、编译和连接
（5）运行程序，分析结果
（6）编写程序文档
习题
1.
程序：一组计算机能识别和执行的指令。一个特定的指令序列用来完成一点过的功能。
程序设计：指从确定任务到得到结果、写出文档的过程
2.
计算机语言解决了人和计算机交流时的语言问题，使得计算机和人都能识别
特点：
2.1高级语言的数据结构要比汇编语言和机器语言丰富
2.2高级语言与具体机器结构关联没有汇编及机器语言密切
2.3高级语言更接近自然语言更容易掌握
2.4高级语言编写的程序要经过编译或解释计算机才能执行
3.
源程序：指未编译的按照一定的程序设计语言规范书写的文本文件，是一系列人类可读的计算机语言指令
目标程序：为源程序经编译可直接被计算机运行的机器码集合，在计算机文件上以.obj作为拓展名
可执行程序：指所有编译后得到的目标模块连接装配起来，在与函数库相连接成为一个整体，生成一个可供计算机执行的目标程序，成为可执行程序
程序编辑：上机输入或编译源程序
程序编译：
先用C提供的“预处理源”，对程序中的预处理指令进行编译预处理
对源程序进行语法检查，判断是否有语法错误，直到没有语法错误为止
编译程序自动把源程序转换为二进制形式的目标程序 .c->.obj
程序连接：将所有的编译后得到的目标模块连接装配起来，在与函数库相连成为一个整体的过程叫做程序连接 .obj->.exe
程序：一组计算机能识别和执行的指令。一个特定的指令序列用来完成一点过的功能
程序模块：可由汇编程序、编译程序、装入程序或翻译程序作为一个整体来处理的一级独立的、可识别的程序指令
程序文件：程序的文件成为程序文件，程序文件存储的是程序，包括源程序和可执行程序
函数：将一段经常需要使用的代码封装起来，在需要使用时可直接调用，来完成一定的功能
主函数：又称main函数，是程序执行的起点
被调用函数：由一个函数调用另一个函数，则称第二个函数为被调用函数
库函数：一般是指编译器提供的可在C源程序中调用的函数，可分为两类，一类是C语言标准规定的库函数，一类是编译器特定的库函数
程序调试：是将编制的程序投入实际运行前，用手工或编译程序等方法进行测试，修正语法错误和逻辑错误的过程
程序调试：是指对一个完成了全部或部分功能、模块的计算机程序正式使用前的检测，以确保该程序能按预定的方式正确运行
4.
#include<stdio.h>
int main()
{
printf("Hello World!\n");
return 0;
}
5.
#include<stdio.h>
int main()
{
printf("*****\n *****\n *****\n *****\n");
return 0;
}
6.
#include<stdio.h>
int main()
{
int max(int x, int y,int e);
printf("请输入三个整数:\n");
int a, b, c, d;
scanf("%d,%d,%d", &a, &b, &c);
d = max(a, b, c);
printf("max=%d\n", d);
return 0;
}
//求三个整数中的较大者的max函数
int max(int x, int y, int e)
{
int z;
if (x > y)z = x;
else if (y > e)z = y;
else z = e;
return(z);
}
2.第二章
算法
2.1 程序=算法（灵魂）+数据结构（身体）
数据结构：对数据的描述
算法：对操作的描述
2.2 什么是算法
数值运算：求数值的解
非数值运算：用于事务管理领域
解决一个问题而采用的方法和步骤称之为算法
2.3 简单的算法举例
算法要具有一般性、通用性和灵活性
2.4 算法的特性
（1）有穷性：一个算法应包含有限的操作步骤，而不是无限的
（2）确定性：算法中的每一个步骤都应当是确定的，而不是含糊的、模棱两可的
（3）有零个或多个输入：所谓输入是指在执行算法时需要从外界取得必要的信息
（4）有一个或多个输出：算法的目的是为了求解，‘解’就是输出
（5）有效性：算法中的每一个步骤都应当能有效地执行，并得到确定的结果
2.5 算法的表示
1.自然语言
2.传统流程图 （棱形框和连接点）
起止框 输入输出框 判断框 处理框 流程线 连接点 注释框
（1）顺序结构
（2）选择结构
（3）循环结构
当型（while型） 直到型（until型）
3.结构化流程图（N/S流程图）
去掉了带箭头的流程线，全部写在一个短距形框中
4.伪代码
用介于自然语言和计算机语言之间的文字和符号来表示算法
与C语言的差别：没有头文件、没有声明变量
2.6 结构化程序设计方法
（1）自上而下
（2）逐步细化
（3）模块化设计
（4）结构化编码
习题
算法：简而言之就是求解问题的步骤，对特定问题求解步骤的一种描述
考大学：志愿表-报名费-准考证-高考-录取通知书-报到
把大象放进冰箱：打开门-放进冰箱-关上门
听演唱会：买票-按时到达-听演唱会
结构化算法：由一些顺序、选择、循环等基本结构按照顺序组成，流程的转移只存在一个基本的范围内
结构化算法便于编写，可读性高，修改和维护起来简单，可以减少程序出错的机会，提高了程序的可靠性，保证了程序的质量，因此提倡结构化的算法
顺序结构：是一种线性、有序的结构。它依次执行各语句模块
选择结构：是根据条件成立与否选择程序执行的通路
循环结构：是重复执行一个或几个模块，知道满足某一条件为止
重新设计基本结构要满足
1.只有一个入口
2.只有一个出口
3.结构内的每一部分都有机会执行到
4.结构内不 存在死循环
略
3.第三章
顺序程序设计
3.1 顺序程序设计举例
#include<stdio.h>
int main()
{
float f, c;
f = 64.0;
c = (5.0 / 9) * (f - 32);
printf("f=%f\nc=%f\n", f, c);
return 0;
}
#include<stdio.h>
int main()
{
float p0 = 1000, r1 = 0.0036, r2 = 0.0225, r3 = 0.0198, p1, p2, p3;
p1 = p0 * (1 + r1);
p2 = p0 * (1 + r2);
p3 = p0 * (1 + r3/2) * (1+r3/2);
printf("p1=%f\np2=%f\np3=%f\n",p1,p2,p3);
return 0;
}
3.2 数据的表现形式及其运算
3.2.1 常量和变量
1.常量：值不能改变的量
（1）整型常量：1000，12345，0，-358
（2）实型常量：
十进制小数形式：123.456，0.123，-56.78
指数形式：12.34e3（12.34*10的三次方）
（3）字符常量：
普通字符：用单括号括起来的一个字符。'a','Z','?'
转义字符：\n ......
（4）字符串常量用双撇号把若干个字符括起来，字符串常量是双撇号中的全部字符（不包括双撇号）
（5）符号常量：用#define指令，指定用一个符号名称代表一个常量（#define PI 3.1416 //注意行末没有分号）
好处：
含义清楚
在需要改变程序中多处用到的同一个常量时，能做到“一改全改“
2.变量：一个有名字的，具有特定属性的一个存储单元
先定义后使用
要区分变量名和变量值
3.常变量
const int a =3；
常变量是有名字的不变量，常量是没有名字的不变量
4.标识符
是一个对象的名字
只能由字母、数字和下划线三种字符组成，且第一个字符必须为字母或下划线
3.2.2数据类型
1.基本类型
整型类型
基本整型（int） 短整型（short int） 长整型（long int） 双长整型（long long int）
字符型（char） 布尔型（bool）
浮点类型
单精度浮点型（float） 双精度浮点型（double） 复数浮点型（float_complex，double_complex,long long_complex）
2.枚举类型(enum)
3.空类型(void)
4.派生类型
指针类型(*)
数组类型（ [ ] ）
结构体类型（struct）
共用体类型（union）
函数类型
3.2.3 整形数据
1.整型数据的分类
（1）基本整型（int 型）
（2）短整型（short int）
（3）长整型（long int）
（4）双长整型（long long int）
2.整型变量的符号属性
int 4
unsigned int 4
short 2
unsigned short 2
long 4
unsigned long 4
long long 8
unsigned long long 8
3.2.4 字符型数据
1.字符与字符代码
字母：52个
数字：0~9
空格符：空格、水平制表符（tab）、垂直制表符、换行、换页
专门的符号：29个
不能显示的字符：空字符（null，以'\0'表示、警告（'\a'）退格（'\b'）、回车（'\r'）
2.字符变量
char定义字符变量
3.浮点型数据
（1）float型 4字节 6个有效数字
（2）double型 8 15
（3）long double型 8 15
16 19
3.2.6 确定常量的类型
整型常量：不带小数点的数值是整型常量（注意有效范围）
浮点型常量：凡事以小数形式或指数形式出现的实数均是浮点型常量，在内存中都以指数形式存储
3.3 运算符和表达式
3.3.1 C运算符
（1）算术运算符
（2）关系运算符
（3）逻辑运算符
（4）位运算符
（5）赋值运算符
（6）条件运算符
（7）逗号运算符
（8）指针运算符
（9）求字节数运算符
（10）强制类型转换运算符
（11）成员运算符
（12）下标运算符
（13）其他
3.3.2 基本的算术运算符
+a
-a
a*b
a/b
a%b
a+b
a-b
3.3.3 自增、自减运算符
++i、--i（先使i的值加减1，再输出）
i++、i--(先输出，再使i的值加减1)
3.3.4 算术表达式和运算符的优先级与结合性
自左向右（左结合性），先乘除后加减
3.3.5 不同类型数据间的混合运算
#include<stdio.h>
int main()
{
char c1, c2;
c1 = 'A';
c2 = c1 + 32;
printf("%c\n",c2); //以字符输出
printf("%d\n", c2); //以ASCII输出值
return 0;
}
3.3.6 强制类型转换运算符
低精度转高精度自动
高精度转低精度强制
（double）a
（int）（x+y）
（float）（5%3）
（类型名）（表达式）
3.4 C语句
3.4.1 C语句的作用和分类
（1）控制语句
(1 if()...else
(2 for()...
(3 whiles()...
(4 do...while()
(5 continue
(6 break
(7 switch
(8 return
(9 goto
（2）函数调用语句：由一个函数调用加一个分号构成
printf（”“）；
（3）表达式语句：由一个表达式加一个分号构成
（4）空语句（什么都不做）
（5）复合语句：用{}把一些语句和声明括起来成为复合语句
3.4.2 赋值语句
#include<stdio.h>
#include<math.h>
int main()
{
double a, b, c, s, area;
a = 3.67;
b = 5.43;
c = 6.21;
s = (a + b + c) / 2;
area = sqrt(s * (s-a) * (s-b) * (s-c)); //计算面积
printf("a=%f\tb=%f\tc=%f\n",a,b,c);
printf("area=%f\n", area);
return 0;
}
1. 赋值运算符
=
2. 复合的赋值运算符
a+=3 等价于 a=a+3
x%=y+3 等价于 x=x%(y+3)
3.赋值表达式
变量 赋值运算符 表达式
将一个表达式的值赋给一个变量
4. 赋值过程中的类型转换
5. 赋值表达式和赋值语句
6. 变量赋初值
3.5 数据的输入输出
3.5.1 输入输出举例
#include<stdio.h>
#include<math.h>
int main()
{
double a, b, c, disc, x1, x2, p, q;
scanf("%1f%1f%1f", &a, &b, &c);
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\nx2=%7.2f\n",x1,x2);
return 0;
}
3.5.2 有关数据输入输出的概念
所谓输入输出是以计算机主机为主体而言的
C语言本身不提供输入输出语句
要在程序文件的开头用预处理指令#include把有关头文件放在本程序中
3.5.3 用printf函数输出数据
1.printf函数的一般格式
printf（格式控制，输出列表）
（1）格式控制：由格式声明和普通字符两部分组成
格式声明：由%和格式字符组成（%d、%f）
普通字符：需要在输出时原样输出的字符
（2）输出列表
printf（参数1，参数2，参数3......）
2.格式字符
（1）d格式符
用来输出一个有符号的十进制整数
（2）c格式符
用来输出一个字符
（3）s格式符
用来输出一个字符串
（4）f格式符
用来输出实数
（1 基本型，用%f
#include<stdio.h>
int main()
{
double a = 1.0;
printf("%f\n",a/3);
return 0;
}
（2 指定数据宽度和小数位数，用%m.nf
#include<stdio.h>
int main()
{
double a = 1.0;
printf("%20.15\n",a/3);
return 0;
}
#include<stdio.h>
int main()
{
float a;
a = 10000 / 3.0;
printf("%f\n", a);
return 0;
}
(3 输出的数据向左对齐，用%-m.nf
#include<stdio.h>
int main()
{
double a = 1.0;
printf("%-25.15,%25.15\n",a,a);
return 0;
}
（5）e格式符
用格式声明%e指定以指数形式输出实数
（6）其他格式符
（1 i格式符：与%d相同
（2 o格式符：以八进制整数形式输出
（3 x格式符：以十六进制数输出整数
（4 u格式符：用来输出无符号型数据，以十进制整数形式输出
（5 g格式符：用来输出浮点数
3.5.4 用是残废函数输入数据
1.scanf函数的一般形式
scanf（格式控制，地址表列）
2.scanf函数中的格式声明
与printf函数类似
3.使用scanf函数时应注意的问题
（1）是残废函数中的格式控制后面应当是变量地址，不是变量名
（2）如果在格式控制字符串中除了格式声明意外还有其它字符，则在输入数据时在对应的位置上应输入与这些字符相同的字符
3.5.5 字符输入输出函数
1.用putchar函数输出一个字符
#include<stdio.h>
int main()
{
char a = 'B', b = 'O', c = 'Y';
putchar(a);
putchar(b);
putchar(c);
putchar('\n');
return 0;
}
2.用getchar函数输入一个字符
#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('\n');
return 0;
}
#include<stdio.h>
int main()
{
char c1, c2;
c1 = getchar();
c2 = c1 + 32;
putchar(c2);
putchar('\n');
return 0;
}
#include<stdio.h>
int main()
{
char c1, c2;
c1 = getchar();
c2 = c1 + 32;
printf("大写字母：%c\n小写字母：%c\n",c1,c2);
return 0;
}
第四章
4.1 选择结构和条件判断
两种选择结构
if...else 两种分支
which 多种分支
#include<stdio.h>
#include<math.h>
int main()
{
double a, b, c, disc, x1, x2, p, q;
scanf("%1f%1f%1f", &a, &b, &c);
disc = b * b - 4 * a * c;
if (disc < 0)
printf("This equation hasn't real roots\n");
else
{
p = -b / (2.0 * a);
q = sqrt(disc) / (2.0 * a);
x1 = p + q;
x2 = p - q;
printf("real roots:\nx1=%7.2f\nx2=%7.2\n", x1, x2);
}
return 0;
}
4.2 用if语句实现选择结构
4.2.1 用if语句处理选择结构举例
#include<stdio.h>
#include<math.h>
int main()
{
float a, b, t;
scanf("%f,%f", &a, &b);
if (a > b)
{
t = a;
a = b;
b = t;
}
printf("%5.2f,%5.2f\n", a, b);
return 0;
}
#include<stdio.h>
#include<math.h>
int main()
{
float a, b, c, t;
scanf("%f,%f.%f", &a, &b, &c);
if (a > b)
{
t = a;
a = b;
b = t;
}
if (a > c)
{
t = a;
a = c;
c = t;
}
if (b > c)
{
t = b;
b = c;
c = t;
}
printf("%5.2f,%5.2f,%5.2f\n", a, b, c);
return 0;
}
4.2.2 if语句的一般形式
if（表达式）语句1
【else 语句2】
（1）if（表达式） 语句1 （没有else子句部分）
（2）if（表达式） （有else子句部分）
语句1
else
语句2
（3）if（表达式1） 语句1 （在else部分又嵌套了多层的if语句）
else if（表达式2） 语句2
else if（表达式3） 语句3
4.3 关系运算符和关系表达式
4.3.1 关系运算符机及其优先次序
<
<=
>
>=
==
!=
前四种优先级别相同（高），后两种优先级别相同（低），前四种大于后两种
关系运算符优先级低于算术运算符
关系运算符优先级高于赋值运算符
4.3.2 关系表达式
用关系运算符将两个数值或数值表达式连接起来的式子，称为关系表达式
4.4 逻辑运算符和逻辑表达式
4.4.1 逻辑运算符及其优先次序
&&(与，and) a&&b
||(或，or) a||b
!(非，not) !a
4.4.2 逻辑表达式
逻辑表达式的值是一个逻辑量“真”或“假”
4.5 条件运算符和条件表达式
表达式1？表达式2：表达式3
等于
if（表达式1）
表达式2
else
表达式3
#include<stdio.h>
#include<math.h>
int main()
{
char ch;
scanf("%c", &ch);
ch = (ch >= 'A' && ch <= 'Z') ? (ch + 32) : ch;
printf("%c\n", ch);
return 0;
}
4.6 选择结构的嵌套
if（）
if（） 语句1
else 语句2
else
if（） 语句3
else 语句4
#include<stdio.h>
#include<math.h>
int main()
{
int x, y;
scanf("%d", &x);
if (x < 0)
y = -1;
else y = 1;
printf("x=%d,y=%d\n", x, y);
return 0;
}
#include<stdio.h>
#include<math.h>
int main()
{
int x, y;
scanf("%d", &x);
if (x >= 0)
if (x > 0)
y = 1;
else y = 0;
else y = -1;
printf("x=%d,y=%d\n", x, y);
return 0;
}
4.7 用switch语句实现多分支选择结构
#include<stdio.h>
#include<math.h>
int main()
{
char grade;
scanf("%c", &grade);
printf("Your score:");
switch (grade)
{
case 'A':printf("85~100\n");
break;
case 'B':printf("70~84\n");
break;
case 'C':printf("60~69\n");
break;
case 'D':printf("<60\n");
break;
default:printf("enter data error!\n");
}
return 0;
}
swithc（表达式）
{
case 常量1：语句1
case 常量2：语句2
... ... ...
case 常量n：语句n
default：语句n+1
}
#include <stdio.h>
#include <math.h>
int main()
{
void actiona1(int, int), action2(int, int);
char ch;
int a = 15, b = 23;
ch = getchar();
switch (ch)
{
case 'a':
case 'A':
action1(a, b);
break;
case 'b':
case 'B':
action2(a, b);
break;
default:
putchar('\a');
}
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);
}
4.8 选择结构程序综合举例
#include <stdio.h>
#include <math.h>
int main()
{
int year, 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 = 1;
}
else
leap = 0;
if (leap)
printf("%d is ", year);
else
printf("%d is not ", year);
printf("a leap year.\n");
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
int year, leap;
printf("enter year:");
scanf("%d", &year);
if (year % 4 != 0)
leap = 0;
else if (year % 100 != 0)
leap = 1;
else if (year % 400 != 0)
leap = 0;
else
leap = 1;
if (leap)
printf("%d is ", year);
else
printf("%d is not ", year);
printf("a leap year.\n");
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
int year, leap;
printf("enter year:");
scanf("%d", &year);
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
leap = 1;
else
leap = 0;
if (leap)
printf("%d is ", year);
else
printf("%d is not ", year);
printf("a leap year.\n");
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
double a, b, c, disc, x1, x2, realpart, imagpart;
scanf("%1f,%1f,%1f", &a, &b, &c);
printf("The equation ");
if (fabs(a) <= 1e-6)
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);
imagpart = sqrt(-disc) / (2 * a);
printf(" has complex roots:\n");
printf("%8.4f+%8.4fi\n", realpart, imagpart);
printf("%8.4f-%8.4fi\n", realpart, imagpart);
}
}
return 0;
}
(有问题)
#include <stdio.h>
int main()
{
int c, s;
float p, w, d, f;
printf("please enter price,weight,discount:");
scanf("%f,%f,%d", &p, &w, &s);
if (s >= 3000)
c = 12;
else
c = s / 250;
switch (c)
{
case 0:
d = 0;
break;
case 1:
d = 2;
break;
case 2:
case 3:
d = 5;
break;
case 4:
case 5:
case 6:
case 7:
d = 8;
break;
case 8:
case 9:
case 10:
case 11:
d = 10;
break;
case 12:
d = 15;
break;
default:
break;
}
f = p * w * s *(1 - d / 100);
printf("freight=%10.2f\n", f);
return 0;
}
习题
1.
算术运算即“四则运算”，是加法、减法、乘法、除法、开方等几种运算的统称。
包括：+、-、*、/、++、--、%等
关系运算有两类：一类是传统的集合运算（并、差、交等）另一类是专门关系运算（选择、投影、连接、除法、外连接等），而在C 语言中，关系运算通常被认为是比较运算，将两个数值进行比较，判断比较结果是否符合给定的条件。
包括：<、<=、>、>=、==、!= 等
逻辑运算有与、或、非三种基本逻辑运算
包括：&&、||、!等
2.
在C语言中逻辑常量只有两个，即0和1，用来表示两个对立的逻辑状态，其中0表示假，1表示真。
对于系统来说，判断一个逻辑量的值时，系统会以0作为假，以非0作为真。
3.
0
1
1
0
1
4.
#include <stdio.h>
int main()
{
int a,b,c;
printf("请输入3个整数：");
scanf("%d,%d,%d",&a,&b,&c);
if(a<b)
if(b<c)
printf("max=%d\n",c);
else
printf("max=%d\n",b);
else if (a<c)
printf("max=%d\n",c);
else
printf("max=%d\n",a);
return 0;
}
或
#include <stdio.h>
int main()
{
int a, b, c, temp, max;
printf("请输入3个整数：");
scanf("%d,%d,%d", &a, &b, &c);
temp = (a > b) ? a : b;
max = (temp > c) ? temp : c;
printf("max=%d\n", max);
return 0;
}
5.
#include <stdio.h>
#include <math.h>
#define M 1000
int main()
{
int i,k;
printf("请输入一个小于%d的整数i：",M);
scanf("%d",&i);
if(i>M)
{
printf("输入的数据不符合要求，请重新输入一个小于%d的整数i：",M);
scanf("%d",&i);
}
k=sqrt(i);
printf("%d的平方根的整数部分是%d\n",i,k);
return 0;
}
优化
#include <stdio.h>
#include <math.h>
#define M 1000
int main()
{
int i,k;
printf("请输入一个小于%d的整数i：",M);
scanf("%d",&i);
while(i>M)
{
printf("输入的数据不符合要求，请重新输入一个小于%d的整数i：",M);
scanf("%d",&i);
}
k=sqrt(i);
printf("%d的平方根的整数部分是%d\n",i,k);
return 0;
}
6.
#include <stdio.h>
#include <math.h>
#define M 1000
int main()
{
int x,y;
printf("输入x：");
scanf("%d",&x);
if(x<1)
{
y=x;
printf("x=%d, y=x=%d\n" ,x,y);
}
else if (x<10)
{
y=2*x-1;
printf("x=%d, y=2*x-1=%d\n",x,y);
}
else
{
y=3*x-11;
printf("x=%d, y=3*x-11=%d\n",x,y);
}
return 0;
}
7.
略
8.
#include <stdio.h>
int main()
{
float score;
char grade;
printf("请输入学生成绩：");
scanf("%f", &score);
while (score > 100 || score < 0)
{
printf("\n输入有误，请重输");
scanf("%f", &score);
}
switch ((int)(score / 10))
{
case 10:
case 9:
grade = 'A';
break;
case 8:
grade = 'B';
break;
case 7:
grade = 'C';
break;
case 6:
grade = 'D';
break;
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:
grade = 'E';
default:
break;
}
printf("成绩是%5.1f,相应的等级是%c\n",score,grade);
return 0;
}
9.
#include <stdio.h>
#include <math.h>
int main()
{
int num, indiv, ten, hundred, thousand, ten_thousand, place;
printf("请输入一个整数（0~99999）：");
scanf("%d", &num);
if (num > 9999)
place = 5;
else if (num > 999)
place = 4;
else if (num > 99)
place = 3;
else if (num > 9)
place = 2;
else
place = 1;
printf("位数：%d\n", place);
printf("每位数字为：");
ten_thousand = num / 10000;
thousand = (int)(num - ten_thousand * 10000) / 1000;
hundred = (int)(num - ten_thousand * 10000 - thousand * 1000) / 100;
ten = (int)(num - ten_thousand * 10000 - thousand * 1000 - hundred * 100) / 10;
indiv = (int)(num - ten_thousand * 10000 - thousand * 1000 - hundred * 100 - ten * 10);
switch (place)
{
case 5:
printf("%d,%d,%d,%d,%d", ten_thousand, thousand, hundred, ten, indiv);
printf("\n反序数字为：");
printf("%d,%d,%d,%d,%d", indiv, ten, hundred, thousand, ten_thousand);
break;
case 4:
printf("%d,%d,%d,%d", thousand, hundred, ten, indiv);
printf("\n反序数字为：");
printf("%d,%d,%d,%d", indiv, ten, hundred, thousand);
case 3:
printf("%d,%d,%d", hundred, ten, indiv);
printf("\n反序数字为：");
printf("%d,%d,%d", indiv, ten, hundred);
case 2:
printf("%d,%d", ten, indiv);
printf("\n反序数字为：");
printf("%d,%d", indiv, ten);
case 1:
printf("%d", indiv);
printf("\n反序数字为：");
printf("%d", indiv);
default:
break;
}
return 0;
}
10.
#include <stdio.h>
#include <math.h>
int main()
{
int i;
double bonus,bon1,bon2,bon4,bon6,bon10;
bon1=100000*0.1;
bon2=bon1+100000*0.075;
bon4=bon2+100000*0.05;
bon6=bon4+100000*0.03;
bon10=bon6+400000*0.015;
printf("请输入利润i：");
scanf("%d",&i);
if(i<=100000)
bonus=i*0.1;
else if(i<=200000)
bonus=bon1+(i-100000)*0.075;
else if(i<400000)
bonus=bon2+(i-200000)*0.05;
else if(i<=400000)
bonus=bon4+(i-400000)*0.03;
else if(i<1000000)
bonus=bon6+(i-600000)*0.015;
else
bonus=bon10+(i-1000000)*0.01;
printf("奖金是：%10.2f\n",bonus);
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
int i;
double bonus, bon1, bon2, bon4, bon6, bon10;
int branch;
bon1 = 100000 * 0.1;
bon2 = bon1 + 100000 * 0.075;
bon4 = bon2 + 100000 * 0.05;
bon6 = bon4 + 100000 * 0.03;
bon10 = bon6 + 400000 * 0.015;
printf("请输入利润i：");
scanf("%d", &i);
branch = i / 100000;
if (branch > 10)
branch = 10;
switch (branch)
{
case 0:
bonus = i * 0.1;
break;
case 1:
bonus = bon1 + (i - 100000) * 0.075;
break;
case 2:
case 3:
bonus = bon2 + (i - 200000) * 0.05;
break;
case 4:
case 5:
bonus = bon4 + (i - 400000) * 0.03;
break;
case 6:
case 7:
case 8:
case 9:
bonus = bon6 + (i - 600000) * 0.015;
break;
case 10:
bonus = bon10 + (i - 1000000) * 0.01;
}
printf("奖金是%10.2f\n", bonus);
return 0;
}
11.
#include <stdio.h>
#include <math.h>
int main()
{
int t,a,b,c,d;
printf("请输入4个数：");
scanf("%d,%d,%d,%d",&a,&b,&c,&d);
printf("a=%d,b=%d,c=%d,d=%d\n",a,b,c,d);
if (a>b)
{t=a;a=b;b=t;}
if(a>c)
{t=a;a=c;c=t;}
if(a>d)
{t=a;a=d;d=t;}
if(b>c)
{t=b;b=c;c=t;}
if(b>d)
{t=b;b=d;d=t;}
if(c>d)
{t=c;c=d;d=t;}
printf("排序结果如下：\n");
printf("%d %d %d %d \n" ,a,b,c,d);
return 0;
}
12.
#include <stdio.h>
#include <math.h>
int main()
{
int h = 10;
float x1 = 2, y1 = 2, x2 = -2, y2 = 2, x3 = -2, y3 = -2, x4 = 2, y4 = -2, x, y, d1, d2, d3, d4;
printf("请输入一个点（x，y）：");
scanf("%f,%f", &x, &y);
d1 = (x - x4) * (x - x4) + (y - y4) * (y - y4);
d2 = (x - x1) * (x - x1) + (y - y1) * (y - y1);
d3 = (x - x2) * (x - x2) + (y - y2) * (y - y2);
d4 = (x - x3) * (x - x3) + (y - y3) * (y - y3);
if (d1 > 1 && d2 > 1 && d3 > 1 && d4 > 1)
h = 0;
printf("该点高度为%d\n", h);
return 0;
}
作者：就想当个宙斯xI 2021,21大学c语言程序设计（谭浩强第五版） - 哔哩哔哩 出处：bilibili
- 第一章
扫一扫
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
