|这个作业属于哪个班级| C语言--网络2011/2012|
|----|----|----|
|这个作业的地址|C博客作业03--函数|
|这个作业的目标| 学习如何设计函数、C语言基本数据类型|
|姓名| 郑俊佳|
1.本章学习总结
1.1 函数定义、调用、声明
void RandOperator(int grade);//函数声明
//函数定义开始
void RandOperator(int grade)
{
char op;
//函数内容
return op;
}
//函数定义结束
int main()
{
char op;
int grade;
scanf("%c",&grade);
printf("%c",RandOperator(grade));//函数调用
return 0;
}
1.2 全局、局部变量、静态局部变量
全局变量:
int grade;
int main()
void RandOperator()
//这里int grade就是全局变量，在主函数&&自定义函数里都可以使用。
局部变量:
int main()
{
int grade;
}
void RandOperator()
//这里int grade就是局部变量，只能在主函数中使用。
静态局部变量:
int main()
{
static int grade=1;
}
void RandOperator()
//这里static int grade=1就是静态局部变量，只在主函数中属于静态，循环后再次回到最初始static int grade=1，grade的值不发生改变。
1.3 C数据类型及注意点
C语言中的三种基本数据类型是：整型、实型、字符型。每种类型又可以分为常量和变量。
整型常量：
(1) 十进制的整型常量：由数字0~9组成。如：0、10、365、-12等。
(2) 八进制的整型常量：以0开头，由数字0~7组成。如：0、010、0365、-012、011等。
(3) 十六进制的整型常量：以0x或0X开头，由数字09、az或A~Z组成。如：0x11、0Xffff、0xa5、-0XAC等。
注：C语言系统默认为基本整型常量。
整型变量：
(1) 根据整数的最高位是否用作符号位，分为有符号(signed)整型和无符号(unsigned)整型。
(2) 根据整数在计算机内存中所占用的空间大小，分为短整型(short int或short)、基本整型(int)和长整型(long int或long)。
short x = 10; 等价于 signed short x = 10; 同时等价于 signed short int x = 10;
int age = 20; 等价于 signed int age = 20;
long z = 10000L; (加L后说明10000是一个长整型常量，而不是一个基本整型常量)
注：
(1) C语言系统默认为有符号整数。
(2) unsigned和signed不能同时出现。
(3) short和long不能同时出现。
实型常量：
在C语言中，实型常量的两种表现形式：小数形式和指数形式。或者叫做小数点式和字母E(或e)式。
(1) 小数点式：
1. 有且仅有一个小数点
2. 小数点的左边和右边可以有一边没有数据，但不能同时没有数据
举例：3.14、0.1、10.、0.0、.0、-10.08
(2) 字母E(或e)式：
1. 有且仅有一个字母E(或e)
2. 两边都必须有数据
3. 左边可以是整数，也可以是小数
4. 右边只能是整数
举例：1e5、1.2E+4、3.0e-2、0e0、1.e0、.0e0
实型变量：
分为单精度和双精度两种，单精度用float表示，双精度用double表示。
举例：
float x = 1., y = .0, z = 1.2E+4;
double salary, sum;
字符型常量：
字符型常量的两种表现形式：
(1) 由一对单引号括起来的单个字符：
举例：'A'、'#'、'x'、'$'
(2) 由一对单引号括起来的，里面是由反斜杠“\”引起的若干字符：
1. 一般转义字符，如：'\t'、'"'、'\'、'\t'、'\n''、'''
2. “\”与其后的1~3位八进制数组成的八进制转义字符，如：'\123'、'\0'、'\61'、'\101'
3. “\x”与其后的1~2位十六进制数组成的十六进制转义字符，如：'\x41'、'\x61'、'\x7F'。注意：不能是大写的“\X”。
字符型变量：
注：字符变量中存放的实际上是该字符的ASCII码，因为字符型数据都被处理成整型数据。
举例：
(1) char a = 'A'; 与 char a = 65; 是等价的。因为字符'A'在计算机中的形式是整型65。
1.4 C运算符
一、分类
C语言一共有34种运算符，10种运算类型：算术运算符（+、-、、/、%）、关系运算符（>、>=、、！=、<、<=）、位运算符(>>、<<、、!=、<、<=)、逻辑运算符(!、||、&&)、条件运算符、（？：）指针运算符（&、）、赋值运算符（=）、逗号运算符（，）、求字节运算符（sizeof）、强制类型转换运算符（（类型名））、其他（下标[]、分量、函数）；若按参与运算的对象个数，C语言运算符可分为单目运算符（如！）、双目运算符（如+、-）和三目运算符（如？：）
二、运算符的结合性和优先级
- 运算符的结合性
在C语言的运算符中，所有的单目运算符、条件运算符、赋值运算符及其扩展运算符，结合方向都是从右向左，其余运算符的结合方向是从左向右。
2.运算符的优先级
初等运算符（圆括号（）、下标运算符[]、结构体成员运算符->）>单目运算符>算术运算符（先乘除后加减）>关系运算符>逻辑运算符（不包括！）条件运算符>赋值运算符>逗号运算符
三、算术运算符合和算术表达式
1.基本的算数运算符
（1） +加法运算或正值运算符
4+4、+5、
（2）- 减法运算或负值运算符
6-4、-10、-29
（3） *乘法运算
注意符号，不是x，而是*
（4） /除法运算
注意符号，不是÷，也不是\，而是/
整数除于整数，还是整数。1/2的值是0，这个并不是二分之一， 不会四舍五入，直接截断取值。
（5）%取余运算
取余：即两个整数相除之后的余数
注意：%两侧只能是整数，正负性取决于%左侧的数值
2.算术表达式
（1）.算术表达式是用算术运算符和括号将运算量（也称操作数）连接起来的、符合C语言语法规则的表达式。其中运算对象包括函数、常量、变量。
（2）.算术表达式的运算规则：
A.在算术表达式中，可以使用多层圆括号，但括号必须配对。运算时从内层括号开始，由内向外依次计算各表达式的值。
B.在算术表达式中，对于不同优先级的运算符，可按运算符的优先级由高到低进行运算，若表达式中运算符的优先级相同，则按运算符的结合方向（算术运算符的结合方向是从左到右）进行运算。
C.如果一个运算符两侧的操作数类型不同，则先利用自动转换或强制转换，使两者具有相同数据类型，然后再进行运算。
四、关系运算(比较运算)和关系表达式
1.关系运算符：
C语言提供了6种关系运算符：>（大于）、>=（大于等于）、==（等于）、！=（不等于）、<（小于）、<=（小于等于）
2.结合性：自左向右：4>3>2，先判断4是否大于3，再判断1是否大于2
3.优先级：关系运算符中（、!=）的优先级相等，（<、<=、>、>=）的优先级相等，且前者的优先级低于后者：23>1，先判断3是否大于1，再判断2是否等于1。
4.关系表达式
(1).定义：由关系运算符连成的表达式。关系运算符的两边可以是C语言中任意合法的表达式。
(2).关系运算符的结果是一个整数值——“0或者1”，用非零值表示“真”，用零值表示“假”
(3).当关系运算符两边值的类型不一致时，系统将自动转化。
5.注意：
A.当关系运算符两边值的类型不一致时，如一边是整型，另一边是实型，系统将自动将整型转化为实型数，然后再进行比较。
B.若复合语句中有关系运算式和算术运算式时，因为算术运算符的优先级高于关系运算符，所以应该先算出算术表达式的值再去判断关系表达式的值。
五、逻辑运算符和逻辑表达式
C语言提供了3中逻辑运算符：
1.&&逻辑与
（1）. 使用格式：
条件A && 条件B；
（2）. 运算结果：
只有当条件A和条件B都成立时，结果才为1，也就是“真”；其余情况的结果都为0，也就是“假”。因此，条件A或条件B只要有一个不成立，结果都为0，也就是“假”
（3）.运算过程：
总是先判断条件A是否成立
如果条件A成立，接着再判断条件B是否成立：如果条件B成立，“条件A && 条件B”的结果就为1，即“真”，如果条件B不成立，结果就为0，即“假”
如果条件A不成立，就不会再去判断条件B是否成立：因为条件A已经不成立了，不管条件B如何，“条件A && 条件B”的结果肯定是0，也就是“假”（逻辑与的“短路的运算”）
（4）.注意：
1>.若想判断a的值是否在(3, 5)范围内，千万不能写成3<a<5，因为关系运算符的结合方向为“从左往右”。 比如a为2，它会先算3<a，也就是3<2，条件不成立，结果为0。再与5比较，即0<5，条件成立，结果为1。因此 3<a<5的结果为1，条件成立，也就是说当a的值为2时，a的值是在(3, 5)范围内的。这明显是不对的。正确的判断方法是：(a>3)&& (a<5)
2>.C语言规定：任何非0值都为“真”，只有0才为“假”。因此逻辑与也适用于数值。比如 5&& 4的结果是1，为“真”；-6 && 0的结果是0，为“假”
2.|| 逻辑或
（1）.使用格式：
条件A || 条件B；
（2）. 运算结果：
当条件A或条件B只要有一个成立时（也包括条件A和条件B都成立），结果就为1，也就是“真”；只有当条件A和条件B都不成立时，结果才为0，也就是“假”。
（3）.运算过程：
总是先判断条件A是否成立
如果条件A成立，就不会再去判断条件B是否成立：因为条件A已经成立了，不管条件B如何，“条件A || 条件B”的结果肯定是1，也就是“真”（逻辑或的“短路运算”）
如果条件A不成立，接着再判断条件B是否成立：如果条件B成立，“条件A || 条件B”的结果就为1，即“真”，如果条件B不成立，结果就为0，即“假”
例：逻辑或的结合方向是“自左至右”。比如表达式(a<3) || (a>5)
若a的值是4：先判断a<3，不成立；再判断a>5，也不成立。因此结果为0
若a的值是2：先判断a<3，成立，停止判断。因此结果为1
因此，如果a的值在(-∞, 3)或者(5, +∞)范围内，结果就为1；否则，结果就为0
（4）.注意：
C语言规定：任何非0值都为“真”，只有0才为“假”。因此逻辑或也适用于数值。比如 5 || 4的结果是1，为“真”；-6 || 0的结果是1，为“真”；0 || 0的结果是0，为“假”。
3.! 逻辑非
（1 ) ！使用格式：
! 条件A；
（2）.运算结果：
其实就是对条件A进行取反：若条件A成立，结果就为0，即“假”；若条件A不成立，结果就为1，即“真”。也就是说：真的变假，假的变真。
例：逻辑非的结合方向是“自右至左”。比如表达式! (a>5)
若a的值是6：先判断a>5，成立，再取反之后的结果为0
若a的值是2：先判断a>3，不成立，再取反之后的结果为1
因此，如果a的值大于5，结果就为0；否则，结果就为1
（3）. 注意：
1.可以多次连续使用逻辑非运算符：!(4>2)结果为0，是“假”，!!(4>2)结果为1，是“真”，!!!(4>2)结果为0，是“假”
2.C语言规定：任何非0值都为“真”，只有0才为“假”。因此，对非0值进行逻辑非!运算的结果都是0，对0值进行逻辑非!运算的结果为1。!5、!6.7、!-9的结果都为0，!0的结果为1
3.结合性：自左向右
4.优先级
逻辑运算符的优先级顺序为： 小括号() > 负号 - > ! > 算术运算符 > 关系运算符 > && > ||
例1：表达式!(3>5) ||(2<4) && (6<1) ：先计算 !(3>5)、(2<4)、(6<1)，结果为1，式子变为1 || 1 && 0，再计算1 && 0，式子变为1 || 0，最后的结果为1
例2：表达式3+2<5||6>3 等价于 ((3+2) < 5) || (6>3)，结果为1
例3：表达式4>3 &&!-5>2 等价于 (4>3) && ((!(-5)) > 2)，结果为0
学习体会
没什么体会，就是更清楚C语言内容
2.综合作业（6分）：小学生口算表达式自动生成系统
2.1.模块流程图
2.2.函数功能及全局变量介绍
2.2.1.全局变量
2.2.2 菜单相关函数
2.2.3 出题相关函数
2.3.运行结果截图，测试用例
2.4.大作业中编程技巧总结
代码提交
//#include<stdio.h>
//#include<windows.h>
//#include<stdlib.h>
//#include<time.h>
char RandOperator(int grade);//控制运算符函数
int RandOperands(int grade);//控制生成随机数函数
void OperateMenu();//游戏操作界面
void GradeOneMenu();//一年级
//void GradetwoMenu();//二年级
//void GradethreeMenu();//三年级
int count=0;//累计正确题目数量
int total=0;//累计总答题数
int main(void)
{
OperateMenu();//游戏操作界面
return 0;
}
void OperateMenu()//游戏操作界面
{
char option;
system("cls");//清屏
do
{
system("cls");
printf("******************************************\n");
printf("1.一年级口算\n");
printf("2.二年级口算\n");
printf("3.三年级口算\n");
printf("4.退出系统\n");
printf("******************************************\n");
printf("请输入您的选择：");
scanf(" %c", &option);
switch (option)
{
case '1':
system("cls");
GradeOneMenu();
//GradeOneMenu();
break;
case '2':
system("cls");
//GradetwoMenu();
break;
case '3':
system("cls");
//GradethreeMenu();
break;
case '4':
printf("\n谢谢您的参与！\n");
Sleep(500);
exit(0);
default:
printf("您输入不对，只能输入1,2,3,4，请重输！\n");
Sleep(500);
}
} while (!(option >= '1' && option <= '4'));
}
void GradeOneMenu()//一年级
{
srand((unsigned int)time(NULL));
while (1)
{
system("cls");
printf("*********************一年级小朋友好！********************************\n");
printf("系统将随机生成一个口算式，如果您会做，则输入y，输入结果。\n");
printf("**如果您不想做，输入n退回主菜单。\n");
printf("***************************************************************\n");
int grade = 1;
char op;
int number1, number2;
int answer;
int right=1;
double acc;
op = RandOperator(grade);
number1 = RandOperands(grade);
number2= RandOperands(grade);
/*1.生成操作数函数*/
/*2.生成随机运算符函数*/
/*3.根据年级判断生成的表达式是否合理的函数（选做）*/
/*4.生成表达式函数，并输出展示*/
while (number1 <= number2&&op=='-')
{
number1 = RandOperands(grade);
number2 = RandOperands(grade);
}
printf("%d%c%d=", number1, op, number2);
printf("是否继续答题y/n：");
char ch;
scanf("\n%c", &ch);
if (ch == 'n')
{
Sleep(500);
double acc;
acc = 1.0*count / total;
printf("%.2f", acc);
Sleep(10000);
OperateMenu();
return;
}
else//选择答题
{
scanf("%d", &answer);
/*答题模块*/
right = RightNumber(number1, op, number2);
printf("%d\n", right);
Sleep(500);
if (answer == right)
{
printf("你很棒！\n");
count++;
}
else
{
printf("继续加油！\n");
}
total++;
printf("%d %d", count, total);
Sleep(500);
}
}
}
char RandOperator(int grade)
{
int num = 0;
char op;
switch (grade)
{
case 1:case 2:num = rand() % 2; break;
case 3:case 4:case 5:case 6:num = rand() % 4; break;
}
switch (num)
{
case 0:op = '+'; break;
case 1:op = '-'; break;
case 2:op = '*'; break;
case 3:op = '/'; break;
}
return op;
}
int RandOperands(int grade)
{
int number;
switch (grade)
{
case 1:number = 1 + rand() % 9; break;
case 2:number = 1 + rand() % 99; break;
case 3:number = 1 + rand() % 999; break;
}
return number;
}
int RightNumber(int number1, char op, int number2)
{
int right = 0;
switch (op)
{
case '+':right = number1 + number2; break;
case'-':right = number1 - number2; break;
case'*':right = number1 * number2; break;
case'/':right = number1 / number2; break;
}
return right;
}