C语言源程序
一个c语言程序由什么构成
C语言源程序由数据类型，常量和变量，数组，指针，字符串，文件输入或输出以及操作组成。
C语言是具有结构化编程，可变范围和递归功能的过程语言。
C语言是面向过程的抽象通用编程语言，在底层开发中广泛使用。
C 语言具有高效，灵活，功能丰富，表达力强和可移植性高的特点，在编程中受到青睐。
C语言编译器通常存在于各种操作系统中，例如Microsoft Windows，macOS，Linux，Unix等。
C语言的设计影响了许多后来的编程语言，例如C ++，Objective-C，Java，C＃等。
c语言被命名为c的原因是c语言起源于Ken Thompson发明的b 语言，而b语言起源于BCPL语言。
1967年，剑桥大学的马丁·理查兹（Martin Richards）简化了CPL 语言，因此诞生了BCPL（基本组合编程语言）语言。
1960年代，美国AT＆T公司AT＆T贝尔实验室的研究员肯·汤普森（Ken Thompson）与手痒无关，他想玩电子游戏《太空旅行》，他将其编辑为模拟太阳系中的航行。
他在老板的背后找到了一台闲置的机器PDP-7。
但是该机器没有操作系统，游戏必须使用该操作系统的某些功能，因此他着手开发用于PDP-7的操作系统。
后来，该操作系统被命名为——UNIX。
1970年，贝尔实验室的肯·汤普森（Ken Thompson）基于BCPL语言，设计了非常简单且接近硬件的B语言（取BCPL的缩写）。
他用B语言编写了第一个UNIX操作系统。
1971年，也爱太空旅行的Dennis M.Ritchie加入了汤普森的开发项目，共同开发UNIX，以便更早地玩游戏。
他的主要工作是转换B语言以使其更加成熟。
[2]1972年，贝尔实验室的D.M. Ritchie最终设计了一种基于B语言的新语言。
他以BCPL的第二个字母作为该语言的名称，这是C语言。
1973年初，C语言的主体完成了。
汤普森和里奇迫不及待想开始用它完全重写UNIX。
《C语言程序设计》基本知识点
《C语言程序设计》基本知识点第一章C语言基本知识1.C源程序的框架尽管各个C源程序的功能千变万化，但框架是不变的，主要有：编译预处理、主函数()、函数n()等，主函数的位置不一定在最前面，可以在程序的中部或后面，主函数的名字固定为main。
2.C语言源程序的书写规则：(1)C源程序是由一个主函数和若干个其它函数组成的。
(2)函数名后必须有小括号，函数体放在大括号内。
(3)C程序必须用小写字母书写。
(4)每句的末尾加分号。
(5)可以一行多句。
(6)可以一句多行。
(7)可以在程序的任何位置加注释。
3.语句种类语句是程序的基本成分，程序的执行就是通过一条条语句的执行而得以实现的，根据表现形式及功能的不同，C语言的基本语句可以分为五大类。
(1)流程控制语句流程控制语句的功能是控制程序的走向，程序的流程有三种基本结构：顺序结构、分支结构和循环结构，任何复杂的程序都可以由这三种基本结构复合而成。
其中后两种结构要用特定的流程控制语句实现。
(2)表达式语句表达式语句的形式是：表达式；，即表达式后跟一分号“；”，分号是语句结束符，是一个语句必不可少的成分。
表达式和表达式语句的区别在于表达式代表的是一个数值，而表达式语句则代表一种动作。
最常见的表达式语句是赋值语句。
(3)函数调用语句函数调用语句实际上也是一种表达式语句，形式为：在一次函数调用的小括号后面加上一个分号。
(4)空语句空语句的形式就是一个分号，它不代表任何动作，常常作为一个意义转折点使用。
(5)复合语句复合语句从形式上看是多个语句的组合，但在语法意义上它只相当于一个语句，在任何单一语句存在的地方都可以是复合语句。
注意复合语句中最后一个语句末尾的分号不能少。
复合语句右大括号后面没有分号。
4.运算符用来表示数据各种操作的符号称为运算符。
运算符实际上代表了一种类型数据的运算规则。
不同的运算符具有不同的运算规则，其操作的数据类型必须符合该运算符的要求，运算结果的数据类型也是固定的。
C语言源程序
C语言程序设计<一>1、程序运行从main()函数开始，也从main()函数结束。
2、函数是C程序的基本单位，由函数头和函数体组成。
3、C语言源程序是由函数组成，它们的数目可以有多个。
4、在C语言源程序中，是必须有一个函数名为main的函数。
main()后的小括号()没有任何内容，它不可以省略。
5、C程序中的语句用分号结束，在一个程序行上可以有多个语句，一个C 语句能写在多个程序行上。
6、函数体是由一对大括号围起来语句序列组成。
小括号是函数的标志。
二、C语言的组成元素1、命令、函数和变量等是组成程序的基本对象，每一个程序对象都需要一个名字来标识，程序对象的名称就是标识符。
2、在C语言中，标识符分为用户标识符和系统标识符。
3、用户标识符是指在程序中由程序员为变量、函数、数组等程序对象自行命名的标识符。
4、系统标识符是指C语言编译系统内部预定义的用于表示命令数据内型的标识符，又称保留字符。
5、基本字符集英文字母:a~z和A~Z。
阿拉伯数字:0~9。
其他字符:（）、[ ]、+、-、*、/、%、<、>、<=、>=、==、！=、！、&&、‖、++、--、+=、-=、*=、/=、%=。
它们是由1~2个字符组成。
用作C语言的运算符；还包括:空格、换行符，回车符，单双引号，大括号，逗号，分号，反斜线，它们在程序中起到分隔和定界作用。
6、标识符:是用于标识命令；变量、函数，数组，数据类型等程序对象名称的字符序列。
7、组成标识符的合法字符有:字母，数字，下划线，三种，数字不能作首字符。
三、执行C语言程序1、单击“开始”——“程序”——“附件”——“命令提示符”。
2、按功能键<10>激活菜单，执行“File”——“NEW”（ALT+回车）全屏。
3、<F2>为保存，输入程序文件名。
4、<Ctrl>+<F9>运行有输入:等待输入→回车通过无输入:返回到编辑未通过:回车→F6→修改F3（打开）<二>一、对数据进行分类二、正确书写C语言中常量1、表示形式:小数形式:只有一个小数点，两边至少一边有数字。
第一章 C语言基本知识
第二章 顺序结构
【考点1】运算符、表达式、语句
运算对象加运算符构成表达式，表达式加分号构成表达式语句，运算对象可以是表达式、常量、变量。如赋值运算符加运算对象构成赋值表达式，赋值表达式加分号又可构成赋值语句。
【考点2】运算符的优先级和结合顺序
【考点3】存储形式
计算机在电脑中保存数据是采用二进制形式，由0或1构成的二进制称为位（bit），八个位构成一个字节（Byte），1个Byte=8个bit。二进制、八进制、十六进制转化为十进制采用乘法，十进制转化为二进制、八进制、十六进制采用除法。数据的存放位置就是它的地址。
【考点4】注释
是对程序的说明，可出现在程序中任意合适的地方，注释从“/*”开始到最近一个“*/”结束，其间任何内容都不会被计算机执行，注释不可以嵌套。
【考点4】条件运算
是唯一的三目运算符，格式为：表达式1?表达式2:表达式3。表达式1值为非0时，整个表达式值为表达式2的值，表达式1值为0时，整个表达式值为表达式3的值。
口诀：真前假后
【考点5】switch语句
格式及执行过程详见教材P33，要注意每条case后有没有break语句的区别。还要注意switch后小括号里面的表达式不能为实型，case后表达式不能有变量。
【考点3】指针变量的初始化
指针变量在使用前必须要初始化，把一个具体的地址赋给它，否则引用时会有副作用，如果不指向任何数据就赋“空值”NULL。
【考点4】指针变量的引用
&是取地址符，*是间接访问运算符，它们是互逆的两个运算符。在指针变量名前加间接访问运算符就等价它所指向的量。
【考点5】指针的运算
C语言源程序至可执行文件步骤
C/C++程序编译步骤如何生成可执行文件电子计算机所使用的是由“0”和“1”组成的二进制数，二进制是计算机的语言的基础。
计算机发明之初，人们只能降贵纡尊，用计算机的语言去命令计算机干这干那，一句话，就是写出一串串由“0”和“1”组成的指令序列交由计算机执行，这种语言，就是机器语言。
想象一下老前辈们在打孔机面前数着一个一个孔的情景，嘘，小声点，你的惊吓可能使他们错过了一个孔，结果可能是导致一艘飞船飞离轨道阿。
为了减轻使用机器语言编程的痛苦，人们进行了一种有益的改进：用一些简洁的英文字母、符号串来替代一个特定的指令的二进制串，比如，用“A D D”代表加法，“MO V”代表数据传递等等，这样一来，人们很容易读懂并理解程序在干什么，纠错及维护都变得方便了，这种程序设计语言就称为汇编语言，即第二代计算机语言。
然而计算机是不认识这些符号的，这就需要一个专门的程序，专门负责将这些符号翻译成二进制数的机器语言，这种翻译程序被称为汇编程序。
因为汇编指令和机器语言之间有着一一对应的关系，这可比英译汉或汉译英简单多了。
高级语言是偏向人，按照人的思维方式设计的，机器对这些可是莫名奇妙，不知所谓。
鱼与熊掌的故事在计算机语言中发生了。
于是必须要有一个桥梁来衔接两者，造桥可不是一件简单的事情。
当你越想方便，那桥就得越复杂。
那高级语言是如何变成机器语言的呢，这个过程让我慢慢道来。
编译：将源代码转换为机器可认识代码的过程。
编译程序读取源程序（字符流），对之进行词法和语法的分析，将高级语言指令转换为功能等效的汇编代码，再由汇编程序转换为机器语言，并且按照操作系统对可执行文件格式的要求链接生成可执行程序。
C源程序－>编译预处理－>编译－>优化程序－>汇编程序－>链接程序－>可执行文件1.编译预处理读取c源程序，对其中的伪指令（以#开头的指令）和特殊符号进行处理。
伪指令主要包括以下四个方面:（1）宏定义指令，如# define Name TokenString,#undef等。
c语言实现单片机控制步进电机加减速源程序
C 语言实现单片机控制步进电机加减速源程序1. 引言在现代工业控制系统中，步进电机作为一种常见的执行元件，广泛应用于各种自动化设备中。
而作为一种常见的嵌入式软件开发语言，C 语言在单片机控制步进电机的加减速过程中具有重要的作用。
本文将从单片机控制步进电机的加减速原理入手，结合 C 语言的编程技巧，介绍如何实现单片机控制步进电机的加减速源程序。
2. 单片机控制步进电机的加减速原理步进电机是一种能够精确控制角度的电机，它通过控制每个步骤的脉冲数来实现旋转。
在单片机控制步进电机的加减速过程中，需要考虑步进电机的加速阶段、匀速阶段和减速阶段。
在加速阶段，需要逐渐增加脉冲的频率，使步进电机的转速逐渐增加；在匀速阶段，需要保持恒定的脉冲频率，使步进电机以匀速旋转；在减速阶段，需要逐渐减小脉冲的频率，使步进电机的转速逐渐减小。
这一过程需要通过单片机的定时器和输出控制来实现。
3. C 语言实现步进电机加减速的源程序在 C 语言中，可以通过操作单片机的 GPIO 来控制步进电机的旋转。
在编写源程序时，需要使用单片机的定时器模块来生成脉冲信号，以控制步进电机的旋转角度和速度。
以下是一个简单的 C 语言源程序，用于实现步进电机的加减速控制：```c#include <reg52.h>void main() {// 初始化定时器// 设置脉冲频率，控制步进电机的加减速过程// 控制步进电机的方向// 控制步进电机的启停}```4. 总结与回顾通过本文的介绍，我们了解了单片机控制步进电机的加减速原理和 C 语言实现步进电机加减速源程序的基本思路。
掌握这些知识之后，我们可以更灵活地应用在实际的嵌入式系统开发中。
在实际项目中，我们还可以根据具体的步进电机型号和控制要求，进一步优化 C 语言源程序，实现更加精准和稳定的步进电机控制。
希望本文能为读者在单片机控制步进电机方面的学习和应用提供一定的帮助。
5. 个人观点与理解在我看来，掌握 C 语言实现单片机控制步进电机加减速源程序的技术是非常重要的。
c语言源程序名的后缀
c语言源程序名的后缀
在Windows操作系统下，C语言源程序后缀为.c。
扩展资料（源程序及代码介绍）：
源程序，是指一系列人类可读的计算机语言指令。
在现代程序语言中，源代码可以是以书籍或者磁带的形式出现；但最常用的格式是文本文件，这种典型格式的目的是为了编译出计算机程序。
源程序文件类型是指源程序存储时使用的殊编码方式，便于读取、识别。
目前，许多程序主要使用高级语言来开发，对于要求执行效率的部分使用低级语言编写，以达到开发效率与运行效率的折中。
C语言源程序后缀为.c ，在windows平台上，编译后的后缀为.obj，连接后的后缀为.exe。
在Linux平台上，预处理后的文件扩展名一般为.i，C语言编译器编译后的文件扩展名一般为.S，是一个汇编代码文件，汇编器编译后的文件扩展一般为.o，链接器生成的可执行文件默认为.out。
一个c语言程序由什么构成
一个C语言程序是由( )。
A) 一个主程序和若干子程序组成B) 函数组成C) 若干过程组成D) 若干子程序组成正确答案B答案解析[解析] 一个C源程序是由一个main函数和若干个其他函数组成的。
函数是C程序的基本单位，被调用的函数可以是系统提供的库函数，也可以是用户根据需要自己定义的函数。
C语言源程序至少具有一个主要功能。
定义函数必须指定四个元素：返回类型，函数名称，括号中的形式参数列表（可以为空）和函数主体。
源程序的结构特征如下1. C语言源程序可以由一个或多个源文件组成。
2.每个源文件可以包含一个或多个功能。
3.无论源程序包含多少文件，都只有一个主要功能，即主要功能。
4.源程序中可以有预处理命令（include命令只是其中之一）。
预处理命令应放在源文件或源程序的前面。
5.每个描述，每个语句都必须以分号结尾。
但是预处理命令，函数标题和大括号“}”后不能跟分号。
6.关键字之间必须至少添加一个空格以指示间隔。
如果有明显的空格字符，也可以不向空格添加空格。
7.在C语言中，有一组相关的控制语句，用于实现选择结构和循环结构：select control statement：if;开关，外壳。
循环控制语句：for，while，do ... While。
转移控制语句：break，continue，goto。
扩展数据C语言的特色1. C语言是一种过程语言，具有结构化编程，可变范围和递归功能。
2.在C语言中，参数按值传递。
另外，还可以传递按值传递的指针。
3.不同的变量类型可以与结构组合。
4.只有32个保留关键字，这使变量和函数的命名更加灵活。
5.可以转换某些变量类型，例如整数和字符变量。
6.通过指针，C语言可以轻松地对存储器进行底层控制。
7.预处理程序使C语言的编译更加灵活。
一个c语言程序由什么构成
一个C语言源程序至少一个有main函数，定义函数必须指定4 个元素：返回类型、函数名、圆括号内的形参表（可能为空）和函数体。
C语言源程序是由：数据类型、常量与变量、数组、指针、字符串、文件输入/输出、运算构成。
源程序的结构特点：
1、一个C语言源程序可以由一个或多个源文件组成。
2、每个源文件可由一个或多个函数组成。
3、一个源程序不论由多少个文件组成，都有一个且只能有一个main函数，即主函数。
4、源程序中可以有预处理命令(include 命令仅为其中的一种)，预处理命令通常应放在源文件或源程序的最前面。
5、每一个说明，每一个语句都必须以分号结尾。
但预处理命令，函数头和花括号“}”之后不能加分号。
6、标识符，关键字之间必须至少加一个空格以示间隔。
若已有明显的间隔符，也可不再加空格来间隔。
7、C语言中，有一组相关的控制语句，用以实现选择结构与循环结构：选择控制语句：if；switch、case。
循环控制语句：for、while、do...while。
转移控制语句：break、continue、goto。
标准c语言源程序文件的后缀
标准c语言源程序文件的后缀标准C语言源程序文件的后缀是.c，这是C语言编写的源程序代码保存的常用后缀名。
在不同的操作系统或编译器中，还可能有其他不同的后缀名，比如在Windows中编译的可能是.exe或.obj，但在Linux中编译的则为.o或.so。
在本文中，我们将会重点解释.c文件的含义和作用。
一、C语言源程序C语言是一种结构化、高级程序设计语言，可以用来编写系统软件、应用软件、嵌入式系统、操作系统等。
C语言的源程序是指程序员所编写的源代码文件，这些文件包含了程序的所有命令、定义、声明和注释等。
通常来说，C语言的源程序包含一定的结构和规范，以方便编译器进行解析和编译成可执行文件或库文件。
C语言源程序通常采用.c后缀来命名，这是由于C语言源程序的特殊性决定的。
C语言编译器可以将.c文件编译成可执行文件或库文件，因此.c文件成为了C语言编写的源程序代码保存的常用后缀名。
在某些编译器中，也可以采用.cpp、.cc、.cxx等后缀，表示C++源程序文件。
C语言源文件通常包含了程序的类定义、函数声明、函数定义、数据类型的定义、宏定义、注释等，它是程序员用C语言编写程序的基石。
C语言源文件的命名形式可以是任意的，但通常情况下会按照语义化命名的原则来命名，以方便阅读和维护代码。
三、C语言源文件的作用C语言源文件是程序员用C语言编写程序的基础，它的作用可以总结如下：1. 定义和声明变量和函数。
2. 定义和引用各种数据类型。
3. 定义和使用宏。
4. 给出注释和说明。
5. 方便程序员进行写、改、查和测试。
6. 最后被编译器编译成可执行文件或库文件供使用。
C语言源文件的编译过程一般包括了以下几个步骤：1. 预处理：编译器根据C语言源文件中的宏、条件编译指令等对源文件进行一些预处理，在编译器编译之前生成中间文件。
2. 编译：编译器将预处理后的源文件编译成目标文件（.o或.obj），其中目标文件是可重定位文件，包含了汇编代码和机器指令。
经典C语言编程30例
经典C语言源代码30例题目：海滩上有一堆桃子，五只猴子来分。
第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？1.程序分析：2.程序源代码：main(){int i,m,j,k,count;for(i=4;i<10000;i+=4){ count=0;m=i;for(k=0;k<5;k++){j=i/4*5+1;i=j;if(j%4==0)count++;elsebreak;}i=m;if(count==4){printf("%d\n",count);break;}}}【程序81】题目：809*??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。
求??代表的两位数，及809*??后的结果。
1.程序分析：2.程序源代码：output(long b,long i){ printf("\n%ld/%ld=809*%ld+%ld",b,i,i,b%i);}main(){long int a,b,i;a=809;for(i=10;i<100;i++){b=i*a+1;if(b>=1000&&b<=10000&&8*i<100&&9*i>=100)output(b,i); }}【程序82】题目：八进制转换为十进制1.程序分析：2.程序源代码：main(){ char *p,s[6];int n;p=s;gets(p);n=0;while(*(p)!='\0'){n=n*8+*p-'0';p++;}printf("%d",n);}【程序83】题目：求0—7所能组成的奇数个数。
c语言源程序的基本组成单位
c语言源程序的基本组成单位1. 引言C语言是一种高级的程序设计语言，被广泛应用于软件开发、操作系统、嵌入式系统等领域。
C语言源程序是C语言开发的基础，也是开发过程中最核心的组成部分。
2. 基本组成单位C语言源程序的基本组成单位是“语句”。
每个语句都是一条具有特定功能的指令，可以完成不同的任务。
语句是C语言执行的最小单元，可以完成一些简单的任务，如定义变量、控制程序流程等。
C语言源程序还包括函数和数据类型。
函数是由多个语句组成的代码块，用于完成一个特定的任务，可以在程序中多次调用。
数据类型是指变量的类型，可以使用不同的数据类型来存储不同类型的数据，如整数、字符、浮点数、数组等。
3. 基本语法C语言源程序具有严格的语法结构。
每个语句都必须以分号（;）结尾，表明一个语句的结束。
函数必须包含在花括号（{}）中，并且函数名必须放在花括号前。
数据类型必须在定义变量时指定，并且变量名必须符合规范。
4. 程序结构C语言源程序的程序结构通常包含头文件、全局变量、函数和主函数。
头文件包含程序所需的库文件和头文件，全局变量是在函数外部定义的变量，函数包括程序所需的函数定义，主函数是程序的入口点。
5. 编译过程C语言源程序需要经过编译过程才能生成可执行文件。
编译器会将源程序转换成机器语言，生成可执行文件。
在编译过程中，编译器会检查语法错误和变量类型错误，如果有错误，编译器将显示错误信息并停止编译。
6. 总结C语言源程序是C语言编程的基础，每个语句都具有特定的功能。
C语言源程序具有严格的语法结构，程序结构通常包括头文件、全局变量、函数和主函数。
C语言源程序需要经过编译过程才能生成可执行文件。
掌握C语言源程序的基本组成单位和语法结构，有助于提高C语言编程的能力和效率。
C语言模拟题
C语言程序设计模拟题(满分共100分)一、单项选择题。
（每小题１分，共20分）1． C语言源程序由预处理命令和( )组成。
（A）函数 (B) 语句 (C) 保留字 (D) 标始符2. 下面程序段中，与if(x%2)中的x%2所表示条件等价的是( )。
scanf("%d",&x);if(x%2) x++;(A)x%2==0 (B) x%2!=1 (C) x%2!=0 (D) x%2==13. 执行下面的C语句序列后，变量b的值是( )。
int a,b,c; a=b=c=1; ++a||++b&&++c;(A) 错误 (B) 0 (C) 2 (D) 14. 设有C语句int a[3][4];，则每次移动过a数组一行元素的指针变量定义形式是( )。
(A)int *p; (B)int **p;(C)int (*p) [4]; (D)int *p[4];5．设有整型变量a, 实型变量f，双精度型变量x，则表达式10+'b'+x*f值的类型为( )。
(A) int (B) float (C) double (D) 不能确定6．C语言中规定，在函数的参数表中,用简单变量做实参时，它和对应形参之间的数据传递方式是( )。
(A)地址传递 (B)单向值传递(C)有实参传给形参，再由形参传回给实参 (D)由用户指定传递方式7．下面程序的输出是（）。
#include <stdio.h>void main(){int x=10,y=3;printf("%d\n",y=x/y);}(A)0 (B)1 (C)3 (D)不确定的值8．执行下面的程序段后，B的值为（）。
int x=35;char z='A';int B;B=((x&15)&&(z<'a'));(A) 0 (B) 1 (C) 2 (D) 39．以下程序的输出结果为（）。
C语言练习作业及答案
C语言练习作业及答案习题一1、C语言源程序最多可能由____ABCD____________部分组成？A)预处理部分B)变量说明部分C)函数原型声明部分D)函数定义部分2、一个完整的C语言源程序最少必须有___C____。
A)若干个主函数B)若干个函数C)且只能有一个主函数D)一个函数3、C语言以函数为源程序的基本单位最主要有利于__B_____。
A)程序设计结构化B)程序设计模块化C)程序设计简单化D提高程序设计有效性4、要使得C语言编写的程序能够在计算机上运行并得出正确结果，必须要先经过______________B_______________________。
A)编辑和链接B)编译和链接C)修改和运行D运行并输入数据5、一个C程序的执行是从______A______。
A)本程序的main函数开始，到main函数结束。
B)本程序文件的第一个函数开始，到本程序文件的最后一个函数结束C)本程序的main函数开始，到本程序文件的最后一个函数结束D)本程序文件的第一个函数开始，到本程序main函数结束6、以下叙述正确的是__A______。
A）在C程序中，main函数必须位于程序的最前面B）C程序的每行中只能写一条语句C）C语言本身没有输入输出语句D）在对一个C程序进行编译的过程中，可发现注释中的拼写错误7、以下叙述不正确的是___D_____。
A）一个C源程序可由一个或多个函数组成B）一个C源程序必须包含一个main函数C）C程序的基本组成单位是函数D）在C程序中，注释说明只能位于一条语句的后面8、C语言规定：在一个源程序中，main函数的位置是___A_____。
A）必须在最开始B）必须在系统调用的库函数的后面C）可以任意D）必须在最后习题二一、程序题1、阅读程序写运行结果（1）#includeintmain(){int某=10,y=6,z=3,t;if(某>y){t=某;某=y;y=t;}if(y>z){t=y;y=z;z=t;}if(某>y){t=某;某=y;y=t;}printf(\return0;}运行结果3610（2）#includeintmain(){intn=123;int某,y,z;某=n/100;y=n0/10;z=n;printf(\return0;}运行结果1,2,3（3）#includeintmain(){int某=10,y=6;printf(\printf(\printf(\return0;}运行结果011（4）#includeintmain(){int某=10,y=6,z=3,=0;+=某;+=y;+=z;printf(\return0;}运行结果19（5）#includeintmain(){inta=2,b=3;float某=3.5,y=2.5;printf(\return0;}运行结果3.5（6）#includeintmain(){inta=-100;unignedb,c;longd=32768;floate=4.56;b=a;a=c=d;printf(\a=e;printf(\return0;}本题假设int型数据占两个字节。
c语言源程序编译的基本单位
c语言源程序编译的基本单位1. C语言源程序编译的基本单位是函数。
一个C程序由多个函数组成，每个函数都有自己的功能和任务。
函数是C语言程序的基本模块，通过函数的调用和执行，实现程序的功能。
2. 在C语言中，函数由函数头和函数体组成。
函数头包括函数的返回类型、函数名和参数列表。
函数体是一系列的语句块，包含了实现具体功能的代码。
3. 在编译C语言源程序时，编译器会逐个处理函数。
编译器首先对函数进行语法检查，确保函数的语法正确。
然后，编译器会对函数进行语义检查，检查变量和表达式的类型是否匹配，以及函数的调用是否正确。
4. 编译器会将函数的源代码翻译成机器可执行的代码。
这个过程包括词法分析、语法分析、语义分析和代码生成等步骤。
词法分析将源代码分解成词法单元，如关键字、标识符、运算符等。
语法分析将词法单元组织成语法结构，并生成语法树。
语义分析检查语法树中的各个部分是否符合语义规则。
代码生成将语法树转换为机器代码。
5. 编译器会将每个函数的机器代码存储在可执行文件中。
可执行文件是由多个函数的机器代码组成的二进制文件。
在运行程序时，操作系统会加载可执行文件到内存中，并按照函数的调用关系执行函数。
6. 在C语言中，函数之间可以相互调用。
一个函数可以在另一个函数中被调用，以实现复杂的功能。
函数之间的调用通过函数名和参数列表实现。
函数的调用会将控制权从当前函数转移到被调用函数，当被调用函数执行完毕后，会返回到调用函数继续执行。
总结：C语言源程序编译的基本单位是函数。
编译器会对每个函数进行语法和语义检查，并将函数的源代码翻译成机器可执行的代码。
编译器会生成可执行文件，其中包含了多个函数的机器代码。
函数之间可以相互调用，以实现复杂的功能。
函数的调用和执行是C语言程序实现功能的基础。
《C语言程序设计基础》教案
教学课题C程序结构课题类型理论课时安排2上课时间教学目标1．掌握C语言源程序的组成2．掌握C语言源程序结构特征教学重点掌握C语言源程序的组成掌握C语言源程序结构特征教学难点掌握C语言源程序结构特征作业布置教学方法教授法教学后记提问：main(){int a,b,m;scanf("%d%d",&a,&b);m=max(a,b);printf("max=%d\n",m);}int max(int x, int y){int t;if(x>y)t=x;elset=y;return t;}（1）用框线标出程序中的函数及它们的函数头和函数体。
（2）写下程序中函数的函数头，进行比较，并写出你的比较结果。
（3）max函数的函数体语句行没有对整齐，你认为这样好吗？（4）在C语言程序中必须要有一个名为main的函数，此说法对吗？知识点，提示学生注意（1）在C程序中/*…*/是注释符，它用于标志程序注释的开始和结束，注释可以增强程序的可读性，它不影响程序语句的执行。
在程序中添加简洁、清晰的注释是一种良好的编程习惯。
（2）在调试程序时，可以把暂时不需要执行的语句放在/*…*/之中，C编译器不会对/*…*/的任何内容进行编译，需要时只需删除语句前后的/*和*/即可，这比不用时删除这些语句，需要的时候再重新录入有更高的效率。
3．根据你对C语言源程序的认识，与同学们讨论完成填空。
（1）C语言源程序是由组成的，它们的数目可以有个。
（2）在C程序中（是/不是）必须有一个函数名为main的函数。
上面例程中main函数后的小括号()没有任何内容，它学生回答注意记忆讨论完成教学课题C程序结构课题类型理论课时安排2上课时间教学目标1．学会正确使用合法的字符和标识符2．了解在Turbo C 2.0中快速地运行C语言程序并查看程序结果教学重点学会正确使用合法的字符和标识符了解在Turbo C 2.0中快速地运行C语言程序并查看程序结果教学难点学会正确使用合法的字符和标识符作业布置教学方法教授法教学后记提问：归纳知识提醒：●标识符必须采用半角西文字符（即纯西文字符），不能用全角的西文字符。
麻将C语言源代码(求完善版)
非吾之力，此资源：求更改，求完善，求分享！邮箱：*****************麻将源代码*/#include "dos.h"#include "stdio.h"#include "graphics.h"#include "bios.h"#include "conio.h"#include "stdlib.h"unsigned char far *video_buffer=(char far *)0xA0000000L;#define VGA256 0x13 /*图形模式13h*/#define TEXT_MODE 0x03 /*普通文本模式*/#define SETVGA Set_Video_Mode(VGA256)#define OUTVGA Set_Video_Mode(TEXT_MODE)#define BYTE unsigned char#define WORD unsigned int#define DWORD unsigned int#define ESC 283#define LEFT 19200#define RIGHT 19712#define H 9064#define ENTER 7181unsigned long int z=54400,zz=0,zy=0,zyy=0,z1=0,zl=10140;int key=0,keyy=0,sing=0,sing1=0,second=0,threes=0;struct chi{int lg;int lgg;}ch[13];struct mj{ char *name; /*名字*/int data1; /*是否已出，无用了*/int data2; /*是否在手中，1为自己，2为对方*/int number; /*同一个花色的第几张，共4张*/}m[136]={"1.bmp",0,0,1,"1.bmp",0,0,2,"1.bmp",0,0,3,"1.bmp",0,0,4,"2.bmp",0,0,1,"2.bmp",0,0,2,"2.bmp",0,0,3,"2.bmp",0,0,4,"3.bmp",0,0,1,"3.bmp",0,0,2,"3.bmp",0,0,3,"3.bmp",0,0,4,"4.bmp",0,0,1,"4.bmp",0,0,2,"4.bmp",0,0,3,"4.bmp",0,0,4,"5.bmp",0,0,1,"5.bmp",0,0,2,"5.bmp",0,0,3,"5.bmp",0,0,4,"6.bmp",0,0,1,"6.bmp",0,0,2,"6.bmp",0,0,3,"6.bmp",0,0,4,"7.bmp",0,0,1,"7.bmp",0,0,2,"7.bmp",0,0,3,"7.bmp",0,0,4,"8.bmp",0,0,1,"8.bmp",0,0,2,"8.bmp",0,0,3,"8.bmp",0,0,4,"9.bmp",0,0,1,"9.bmp",0,0,2,"9.bmp",0,0,3,"9.bmp",0,0,4,"10.bmp",0,0,1,"10.bmp",0,0,2,"10.bmp",0,0,3,"10.bmp",0,0,4,"11.bmp",0,0,1,"11.bmp",0,0,2,"11.bmp",0,0,3,"11.bmp",0,0,4,"12.bmp",0,0,1,"12.bmp",0,0,2,"12.bmp",0,0,3,"12.bmp",0,0,4,"13.bmp",0,0,1,"13.bmp",0,0,2,"13.bmp",0,0,3,"13.bmp",0,0,4,"14.bmp",0,0,1,"14.bmp",0,0,2,"14.bmp",0,0,3,"14.bmp",0,0,4,"15.bmp",0,0,1,"15.bmp",0,0,2,"15.bmp",0,0,3,"15.bmp",0,0,4,"19.bmp",0,0,4,"20.bmp",0,0,1,"20.bmp",0,0,2,"20.bmp",0,0,3,"20.bmp",0,0,4, "21.bmp",0,0,1,"21.bmp",0,0,2,"21.bmp",0,0,3,"21.bmp",0,0,4,"22.bmp",0,0,1, "22.bmp",0,0,2,"22.bmp",0,0,3,"22.bmp",0,0,4,"23.bmp",0,0,1,"23.bmp",0,0,2, "23.bmp",0,0,3,"23.bmp",0,0,4,"24.bmp",0,0,1,"24.bmp",0,0,2,"24.bmp",0,0,3, "24.bmp",0,0,4,"25.bmp",0,0,1,"25.bmp",0,0,2,"25.bmp",0,0,3,"25.bmp",0,0,4, "26.bmp",0,0,1,"26.bmp",0,0,2,"26.bmp",0,0,3,"26.bmp",0,0,4,"27.bmp",0,0,1, "27.bmp",0,0,2,"27.bmp",0,0,3,"27.bmp",0,0,4,"28.bmp",0,0,1,"28.bmp",0,0,2, "28.bmp",0,0,3,"28.bmp",0,0,4,"29.bmp",0,0,1,"29.bmp",0,0,2,"29.bmp",0,0,3, "29.bmp",0,0,4,"30.bmp",0,0,1,"30.bmp",0,0,2,"30.bmp",0,0,3,"30.bmp",0,0,4, "31.bmp",0,0,1,"31.bmp",0,0,2,"31.bmp",0,0,3,"31.bmp",0,0,4,"32.bmp",0,0,1, "32.bmp",0,0,2,"32.bmp",0,0,3,"32.bmp",0,0,4,"33.bmp",0,0,1,"33.bmp",0,0,2, "33.bmp",0,0,3,"33.bmp",0,0,4,"34.bmp",0,0,1,"34.bmp",0,0,2,"34.bmp",0,0,3, "34.bmp"};struct every{ int *k; /*名字*/int oneorfour; /*同一张牌的第几张*/int number; /*第几张牌136*/int p;int g;int c;int d[2];};struct me{ int m; /*定义有几张牌，开始有13张随着游戏的进行，会越来越小*/int p; /*乓对方*/int c; /*吃对方*/int g; /*杠*/struct every pp[14]; /*存放手上的牌*/}me;struct computer{ int m;int p;int c;int g;struct every pp[14];}computer,comp;/* 设置调色板 */void Set_Palette(int Color,BYTE r,BYTE g,BYTE b){outportb(0x3c8,Color); /*0x3c8写端口写色号*/outportb(0x3c9,r); /*0x3c9数据端口 R、G、B的比例*/outportb(0x3c9,g);outportb(0x3c9,b);}/*0x3c7读端口 0x3c6计算机调色板寄存器调用端口*//* 设置显示模式的函数 */void Set_Video_Mode(int mode){union REGS inregs,outregs; /*定义输入和返回寄存器*/}void h_line(int x0,int x1,int y,unsigned int color) { unsigned int address,n,temp;if(x0>x1){temp=x1;x1=x0;x0=temp;}address=320*y+x0;for(n=0;n<=x1-x0;n++){video_buffer[address]=color;address+=1;}}void p_pixel(int x,int y,unsigned int color){ video_buffer[y*320+x]=color;}void s_square(int x,int y,int side,int color){h_line(x,x+side,y,color);h_line(x,x+side,y+side,color);v_line(y,y+side,x,color);v_line(y,y+side,x+side,color);}void r_rectangle(int x1,int y1,int x2,int y2,int color) {h_line(x1,x2,y1,color);h_line(x1,x2,y2,color);v_line(y1,y2,x1,color);v_line(y1,y2,x2,color);}void fillRectangle(int x1,int y1,int x2,int y2,int color) {int i;for(i=y1;i<=y2;i++){h_line(x1,x2,i,color);}}void showbmp(int l)bmp=fopen(me.pp[l].k,"rb");fseek(bmp,54,SEEK_SET);for(i=0;i<256;i++){palette[i][2]=fgetc(bmp)>>2;palette[i][1]=fgetc(bmp)>>2;palette[i][0]=fgetc(bmp)>>2;fgetc(bmp);Set_Palette(i,palette[i][0],palette[i][1],palette[i][2]); }for (y=0;y<30;y++)for(x=0;x<20;x++)pokeb(0xa000,y*320+x+z+zz+z1,fgetc(bmp)); fclose(bmp);}void showbmpd(int l){ FILE *bmp;int i,x,y;BYTE palette[256][3];bmp=fopen(me.pp[l].k,"rb");fseek(bmp,54,SEEK_SET);for(i=0;i<256;i++){palette[i][2]=fgetc(bmp)>>2;palette[i][1]=fgetc(bmp)>>2;palette[i][0]=fgetc(bmp)>>2;fgetc(bmp);Set_Palette(i,palette[i][0],palette[i][1],palette[i][2]); }for (y=0;y<30;y++)for(x=0;x<20;x++)pokeb(0xa000,y*320+x+zyy,fgetc(bmp));fclose(bmp);}void showybmp(int ll){ FILE *bmp;int i,x,y;BYTE palette[256][3];bmp=fopen(computer.pp[ll].k,"rb");fseek(bmp,54,SEEK_SET);for(i=0;i<256;i++){palette[i][2]=fgetc(bmp)>>2;palette[i][1]=fgetc(bmp)>>2;palette[i][0]=fgetc(bmp)>>2;fgetc(bmp);Set_Palette(i,palette[i][0],palette[i][1],palette[i][2]); }for (y=0;y<30;y++)for(x=0;x<20;x++)void showcbmp(int ll){ FILE *bmp;int i,x,y;BYTE palette[256][3];bmp=fopen(computer.pp[ll].k,"rb");fseek(bmp,54,SEEK_SET);for(i=0;i<256;i++){palette[i][2]=fgetc(bmp)>>2;palette[i][1]=fgetc(bmp)>>2;palette[i][0]=fgetc(bmp)>>2;fgetc(bmp);Set_Palette(i,palette[i][0],palette[i][1],palette[i][2]); }for (y=0;y<30;y++)for(x=0;x<20;x++)pokeb(0xa000,y*320+x+zyy,fgetc(bmp));fclose(bmp);}void bmpp(int number){ FILE *bmp;int i,x,y;BYTE palette[256][3];bmp=fopen(m[number].name,"rb");fseek(bmp,54,SEEK_SET);for(i=0;i<256;i++){palette[i][2]=fgetc(bmp)>>2;palette[i][1]=fgetc(bmp)>>2;palette[i][0]=fgetc(bmp)>>2;fgetc(bmp);Set_Palette(i,palette[i][0],palette[i][1],palette[i][2]); }for (y=0;y<30;y++)for(x=0;x<20;x++)pokeb(0xa000,y*320+x+zl,fgetc(bmp));fclose(bmp);}void comlipai() /*整理电脑的牌*/{ int n,j,u;for(j=n;j<computer.m;j++){if(computer.pp[n].number>computer.pp[j+1].number) {lingshi=computer.pp[n].k;computer.pp[n].k=computer.pp[j+1].k;computer.pp[j+1].k=lingshi;u=computer.pp[n].oneorfour;computer.pp[n].oneorfour=computer.pp[j+1].oneorfour; computer.pp[j+1].oneorfour=u;u=computer.pp[n].number;computer.pp[n].number=computer.pp[j+1].number; computer.pp[j+1].number=u;}elseif(computer.pp[n].number==computer.pp[j+1].number)if(computer.pp[n].oneorfour>computer.pp[j+1].oneorfour) {lingshi=computer.pp[n].k;computer.pp[n].k=computer.pp[j+1].k;computer.pp[j+1].k=lingshi;u=computer.pp[n].oneorfour;computer.pp[n].oneorfour=computer.pp[j+1].oneorfour; computer.pp[j+1].oneorfour=u;u=computer.pp[n].number;computer.pp[n].number=computer.pp[j+1].number; computer.pp[j+1].number=u;}}}void melipai(){ int n,j,u;int *lingshi;for(n=0;n<me.m;n++)for(j=n;j<me.m;j++){if(me.pp[n].number>me.pp[j+1].number){lingshi=me.pp[n].k;me.pp[n].k=me.pp[j+1].k;me.pp[j+1].k=lingshi;u=me.pp[n].oneorfour;me.pp[n].oneorfour=me.pp[j+1].oneorfour;me.pp[j+1].oneorfour=u;u=me.pp[n].number;me.pp[n].number=me.pp[j+1].number;me.pp[j+1].number=u;}elseif(me.pp[n].number==me.pp[j+1].number)me.pp[n].k=me.pp[j+1].k;me.pp[j+1].k=lingshi;u=me.pp[n].oneorfour;me.pp[n].oneorfour=me.pp[j+1].oneorfour;me.pp[j+1].oneorfour=u;u=me.pp[n].number;me.pp[n].number=me.pp[j+1].number;me.pp[j+1].number=u;}}}void rgzn(int c) /*本程序涵数的核心针对电脑的牌*/ { int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;if(me.pp[c].number<=35 && me.pp[c].number>=0){logo=1;if(me.pp[c].number<=3 && me.pp[c].number>=0) logoo=1;else if(me.pp[c].number<=7 && me.pp[c].number>=4) logoo=2;else if(me.pp[c].number<=11 && me.pp[c].number>=8) logoo=3;else if(me.pp[c].number<=15 && me.pp[c].number>=12) logoo=4;else if(me.pp[c].number<=19 && me.pp[c].number>=16) logoo=5;else if(me.pp[c].number<=23 && me.pp[c].number>=20) logoo=6;[1] [2]else if(me.pp[c].number<=27 && me.pp[c].number>=24) logoo=7;else if(me.pp[c].number<=31 && me.pp[c].number>=28) logoo=8;else if(me.pp[c].number<=35 && me.pp[c].number>=32) logoo=9;}if(me.pp[c].number<=39 && me.pp[c].number>=36) logoo=1;else if(me.pp[c].number<=43 && me.pp[c].number>=40) logoo=2;else if(me.pp[c].number<=47 && me.pp[c].number>=44) logoo=3;else if(me.pp[c].number<=51 && me.pp[c].number>=48) logoo=4;else if(me.pp[c].number<=55 && me.pp[c].number>=52) logoo=5;else if(me.pp[c].number<=59 && me.pp[c].number>=56) logoo=6;else if(me.pp[c].number<=63 && me.pp[c].number>=60) logoo=7;else if(me.pp[c].number<=67 && me.pp[c].number>=64) logoo=8;else if(me.pp[c].number<=71 && me.pp[c].number>=68) logoo=9;}else if(me.pp[c].number<=107 && me.pp[c].number>=72) {logo=3;if(me.pp[c].number<=75 && me.pp[c].number>=72) logoo=1;else if(me.pp[c].number<=79 && me.pp[c].number>=76) logoo=2;else if(me.pp[c].number<=83 && me.pp[c].number>=80) logoo=3;else if(me.pp[c].number<=87 && me.pp[c].number>=84) logoo=4;else if(me.pp[c].number<=91 && me.pp[c].number>=88) logoo=5;else if(me.pp[c].number<=95 && me.pp[c].number>=92) logoo=6;else if(me.pp[c].number<=99 && me.pp[c].number>=96) logoo=7;else if(me.pp[c].number<=103 && me.pp[c].number>=100) logoo=8;else if(me.pp[c].number<=107 && me.pp[c].number>=104) logoo=9;}else if(me.pp[c].number<=135 && me.pp[c].number>=108) {logo=4;if(me.pp[c].number<=111 && me.pp[c].number>=108) logoo=1;else if(me.pp[c].number<=115 && me.pp[c].number>=112) logoo=2;else if(me.pp[c].number<=119 && me.pp[c].number>=116) logoo=3;else if(me.pp[c].number<=131 && me.pp[c].number>=128)logoo=6;else if(me.pp[c].number<=135 && me.pp[c].number>=132)logoo=7;}while(b<=computer.m){if(computer.pp[b].number<=35 && computer.pp[b].number>=0)/*假定电脑经过分析后出了第一张牌*/{lg=1;computer.pp[b].d[0]=1;if(computer.pp[b].number<=3 && computer.pp[b].number>=0){lgg=1;computer.pp[b].d[1]=1;}else if(computer.pp[b].number<=7 && computer.pp[b].number>=4) {lgg=2;computer.pp[b].d[1]=2;}else if(computer.pp[b].number<=11 && computer.pp[b].number>=8) {lgg=3;computer.pp[b].d[1]=3;}else if(computer.pp[b].number<=15 && computer.pp[b].number>=12) {lgg=4;computer.pp[b].d[1]=4;}else if(computer.pp[b].number<=19 && computer.pp[b].number>=16) {lgg=5;computer.pp[b].d[1]=5;}else if(computer.pp[b].number<=23 && computer.pp[b].number>=20) {lgg=6;computer.pp[b].d[1]=6;}else if(computer.pp[b].number<=27 && computer.pp[b].number>=24) {lgg=7;computer.pp[b].d[1]=7;computer.pp[b].d[1]=8;}else if(computer.pp[b].number<=35 && computer.pp[b].number>=32) {lgg=9;computer.pp[b].d[1]=9;}}else if(computer.pp[b].number<=71 && computer.pp[b].number>=36) {lg=2;computer.pp[b].d[0]=2;if(computer.pp[b].number<=39 && computer.pp[b].number>=36) {lgg=1;computer.pp[b].d[1]=1;}else if(computer.pp[b].number<=43 && computer.pp[b].number>=40) {lgg=2;computer.pp[b].d[1]=2;}else if(computer.pp[b].number<=47 && computer.pp[b].number>=44) {lgg=3;computer.pp[b].d[1]=3;}else if(computer.pp[b].number<=51 && computer.pp[b].number>=48) {lgg=4;computer.pp[b].d[1]=4;}else if(computer.pp[b].number<=55 && computer.pp[b].number>=52) {lgg=5;computer.pp[b].d[1]=5;}else if(computer.pp[b].number<=59 && computer.pp[b].number>=56) {lgg=6;computer.pp[b].d[1]=6;}else if(computer.pp[b].number<=63 && computer.pp[b].number>=60) {lgg=7;computer.pp[b].d[1]=7;}else if(computer.pp[b].number<=67 && computer.pp[b].number>=64) {else if(computer.pp[b].number<=71 && computer.pp[b].number>=68) {lgg=9;computer.pp[b].d[1]=9;}}else if(computer.pp[b].number<=107 && computer.pp[b].number>=72) {lg=3;computer.pp[b].d[0]=3;if(computer.pp[b].number<=75 && computer.pp[b].number>=72){lgg=1;computer.pp[b].d[1]=1;}else if(computer.pp[b].number<=79 && computer.pp[b].number>=76) {lgg=2;computer.pp[b].d[1]=2;}else if(computer.pp[b].number<=83 && computer.pp[b].number>=80) {lgg=3;computer.pp[b].d[1]=3;}else if(computer.pp[b].number<=87 && computer.pp[b].number>=84) {lgg=4;computer.pp[b].d[1]=4;}else if(computer.pp[b].number<=91 && computer.pp[b].number>=88) {lgg=5;computer.pp[b].d[1]=5;}else if(computer.pp[b].number<=95 && computer.pp[b].number>=92) {lgg=6;computer.pp[b].d[1]=6;}else if(computer.pp[b].number<=99 && computer.pp[b].number>=96) {lgg=7;computer.pp[b].d[1]=7;}else if(computer.pp[b].number<=103 && computer.pp[b].number>=100) {lgg=8;computer.pp[b].d[1]=8;}else if(computer.pp[b].number<=107 && computer.pp[b].number>=104)computer.pp[b].d[1]=9;}}else if(computer.pp[b].number<=135 && computer.pp[b].number>=108) {lg=4;computer.pp[b].d[0]=4;if(computer.pp[b].number<=111 && computer.pp[b].number>=108) {lgg=1;computer.pp[b].d[1]=1;}else if(computer.pp[b].number<=115 && computer.pp[b].number>=112) {lgg=2;computer.pp[b].d[1]=2;}else if(computer.pp[b].number<=119 && computer.pp[b].number>=116) {lgg=3;computer.pp[b].d[1]=3;}else if(computer.pp[b].number<=123 && computer.pp[b].number>=120) {lgg=4;computer.pp[b].d[1]=4;}else if(computer.pp[b].number<=127 && computer.pp[b].number>=124) {lgg=5;computer.pp[b].d[1]=5;}else if(computer.pp[b].number<=131 && computer.pp[b].number>=128) {lgg=6;computer.pp[b].d[1]=6;}else if(computer.pp[b].number<=135 && computer.pp[b].number>=132) {lgg=7;computer.pp[b].d[1]=7;}}ch[b].lg=lg; /*保存电脑手里的每张牌的信息*/ ch[b].lgg=lgg;lg=0;lgg=0;b++;}if(pg==2) /*乓*/{sing=1;b=computer.m;while(b!=-1){if(strcmp(me.pp[c].k,computer.pp[b].k)==0) computer.pp[b].p=1;b--;}}if(pg==3) /*杠*/{sing=2;b=computer.m;while(b!=-1){if(strcmp(me.pp[c].k,computer.pp[b].k)==0) computer.pp[b].g=1;b--;}}f=0;while(f<computer.m) /*吃的判断*/{ if(ch[f].lg==logo && ch[f].lg!=4){if(ch[f+1].lgg-ch[f].lgg==1) /*顺吃*/if(ch[f].lgg-logoo==1){gp++;computer.pp[f].c=1;computer.pp[f+1].c=1;}if(ch[f].lgg-ch[f+1].lgg==-1) /*逆吃*/if(ch[f+1].lgg-logoo==-1){gp++;computer.pp[f].c=1;computer.pp[f+1].c=1;}if(ch[f].lgg-logoo==-1) /*中吃*/computer.pp[f].c=1;computer.pp[f+1].c=1;}if(gp==1)break;}f++;}if(gp==1){sing=7;}pg=0;gp=0;b=0;}void rgznme(int c) /*本程序涵数的核心针对我的牌*/{ int b=0,lg,lgg,logo,logoo,pg=0,gp=0,cs=0,f=0;if(computer.pp[c].number<=35 && computer.pp[c].number>=0){logo=1;if(computer.pp[c].number<=3 && computer.pp[c].number>=0) logoo=1;else if(computer.pp[c].number<=7 && computer.pp[c].number>=4) logoo=2;else if(computer.pp[c].number<=11 && computer.pp[c].number>=8) logoo=3;else if(computer.pp[c].number<=15 && computer.pp[c].number>=12) logoo=4;else if(computer.pp[c].number<=19 && computer.pp[c].number>=16) logoo=5;else if(computer.pp[c].number<=23 && computer.pp[c].number>=20) logoo=6;else if(computer.pp[c].number<=27 && computer.pp[c].number>=24) logoo=7;else if(computer.pp[c].number<=31 && computer.pp[c].number>=28) logoo=8;else if(computer.pp[c].number<=35 && computer.pp[c].number>=32) logoo=9;}else if(computer.pp[c].number<=71 && computer.pp[c].number>=36) {logo=2;if(computer.pp[c].number<=39 && computer.pp[c].number>=36) logoo=1;else if(computer.pp[c].number<=43 && computer.pp[c].number>=40) logoo=2;else if(computer.pp[c].number<=47 && computer.pp[c].number>=44) logoo=3;else if(computer.pp[c].number<=51 && computer.pp[c].number>=48)else if(computer.pp[c].number<=59 && computer.pp[c].number>=56) logoo=6;else if(computer.pp[c].number<=63 && computer.pp[c].number>=60) logoo=7;else if(computer.pp[c].number<=67 && computer.pp[c].number>=64) logoo=8;else if(computer.pp[c].number<=71 && computer.pp[c].number>=68) logoo=9;}else if(computer.pp[c].number<=107 && computer.pp[c].number>=72) {logo=3;if(computer.pp[c].number<=75 && computer.pp[c].number>=72) logoo=1;else if(computer.pp[c].number<=79 && computer.pp[c].number>=76) logoo=2;else if(computer.pp[c].number<=83 && computer.pp[c].number>=80) logoo=3;else if(computer.pp[c].number<=87 && computer.pp[c].number>=84) logoo=4;else if(computer.pp[c].number<=91 && computer.pp[c].number>=88) logoo=5;else if(computer.pp[c].number<=95 && computer.pp[c].number>=92) logoo=6;else if(computer.pp[c].number<=99 && computer.pp[c].number>=96) logoo=7;else if(computer.pp[c].number<=103 && computer.pp[c].number>=100) logoo=8;else if(computer.pp[c].number<=107 && computer.pp[c].number>=104) logoo=9;}else if(computer.pp[c].number<=135 && computer.pp[c].number>=108) {logo=4;if(computer.pp[c].number<=111 && computer.pp[c].number>=108) logoo=1;else if(computer.pp[c].number<=115 && computer.pp[c].number>=112) logoo=2;else if(computer.pp[c].number<=119 && computer.pp[c].number>=116) logoo=3;else if(computer.pp[c].number<=123 && computer.pp[c].number>=120) logoo=4;else if(computer.pp[c].number<=127 && computer.pp[c].number>=124) logoo=5;else if(computer.pp[c].number<=131 && computer.pp[c].number>=128) logoo=6;else if(computer.pp[c].number<=135 && computer.pp[c].number>=132) logoo=7;}while(b<=me.m){lg=1;me.pp[b].d[0]=1;if(me.pp[b].number<=3 && me.pp[b].number>=0){lgg=1;me.pp[b].d[1]=1;}else if(me.pp[b].number<=7 && me.pp[b].number>=4) {lgg=2;me.pp[b].d[1]=2;}else if(me.pp[b].number<=11 && me.pp[b].number>=8) {lgg=3;me.pp[b].d[1]=3;}else if(me.pp[b].number<=15 && me.pp[b].number>=12) {lgg=4;me.pp[b].d[1]=4;}else if(me.pp[b].number<=19 && me.pp[b].number>=16) {lgg=5;me.pp[b].d[1]=5;}else if(me.pp[b].number<=23 && me.pp[b].number>=20) {lgg=6;me.pp[b].d[1]=6;}else if(me.pp[b].number<=27 && me.pp[b].number>=24) {lgg=7;me.pp[b].d[1]=7;}else if(me.pp[b].number<=31 && me.pp[b].number>=28) {lgg=8;me.pp[b].d[1]=8;}else if(me.pp[b].number<=35 && me.pp[b].number>=32) {lgg=9;me.pp[b].d[1]=9;}}else if(me.pp[b].number<=71 && me.pp[b].number>=36) {if(me.pp[b].number<=39 && me.pp[b].number>=36){lgg=1;me.pp[b].d[1]=1;}else if(me.pp[b].number<=43 && me.pp[b].number>=40) {lgg=2;me.pp[b].d[1]=2;}else if(me.pp[b].number<=47 && me.pp[b].number>=44) {lgg=3;me.pp[b].d[1]=3;}else if(me.pp[b].number<=51 && me.pp[b].number>=48) {lgg=4;me.pp[b].d[1]=4;}else if(me.pp[b].number<=55 && me.pp[b].number>=52) {lgg=5;me.pp[b].d[1]=5;}else if(me.pp[b].number<=59 && me.pp[b].number>=56) {lgg=6;me.pp[b].d[1]=6;}else if(me.pp[b].number<=63 && me.pp[b].number>=60) {lgg=7;me.pp[b].d[1]=7;}else if(me.pp[b].number<=67 && me.pp[b].number>=64) {lgg=8;me.pp[b].d[1]=8;}else if(me.pp[b].number<=71 && me.pp[b].number>=68) {lgg=9;me.pp[b].d[1]=9;}}else if(me.pp[b].number<=107 && me.pp[b].number>=72) {lg=3;me.pp[b].d[0]=3;if(me.pp[b].number<=75 && me.pp[b].number>=72)}else if(me.pp[b].number<=79 && me.pp[b].number>=76) {lgg=2;me.pp[b].d[1]=2;}else if(me.pp[b].number<=83 && me.pp[b].number>=80) {lgg=3;me.pp[b].d[1]=3;}else if(me.pp[b].number<=87 && me.pp[b].number>=84) {lgg=4;me.pp[b].d[1]=4;}else if(me.pp[b].number<=91 && me.pp[b].number>=88) {lgg=5;me.pp[b].d[1]=5;}else if(me.pp[b].number<=95 && me.pp[b].number>=92) {lgg=6;me.pp[b].d[1]=6;}else if(me.pp[b].number<=99 && me.pp[b].number>=96) {lgg=7;me.pp[b].d[1]=7;}else if(me.pp[b].number<=103 && me.pp[b].number>=100) {lgg=8;me.pp[b].d[1]=8;}else if(me.pp[b].number<=107 && me.pp[b].number>=104) {lgg=9;me.pp[b].d[1]=9;}}else if(me.pp[b].number<=135 && me.pp[b].number>=108)if(me.pp[b].number<=111 && me.pp[b].number>=108) {lgg=1;me.pp[b].d[1]=1;}else if(me.pp[b].number<=115 && me.pp[b].number>=112) {lgg=2;me.pp[b].d[1]=2;}else if(me.pp[b].number<=119 && me.pp[b].number>=116) {lgg=3;me.pp[b].d[1]=3;}else if(me.pp[b].number<=123 && me.pp[b].number>=120) {lgg=4;me.pp[b].d[1]=4;}else if(me.pp[b].number<=127 && me.pp[b].number>=124) {lgg=5;me.pp[b].d[1]=5;}else if(me.pp[b].number<=131 && me.pp[b].number>=128) {lgg=6;me.pp[b].d[1]=6;}else if(me.pp[b].number<=135 && me.pp[b].number>=132) {lgg=7;me.pp[b].d[1]=7;}}}}void istwo(testt)int testt[];{ if(testt[0]==testt[1])second++;}void isthree(testt,n)int testt[],n=0;{ int i,j,flage=0,lianx=0,same=0;n=n/3;for(j=0;j<n;j++){for(i=j*3;i<2+j*3;i++)same++;if(testt[i+1]-testt[i]==1)lianx++;}if(same==2)threes++;if(lianx==2)threes++;same=0;lianx=0;}}void panduan() /*本程序的精髓*/{int data[14];int pw[14];int pt[14];int pi[14];int pf[14];int test[12];int jj,w,mm,nn,tpp=0,lp=0,ww=0,tt=0,ii=0,ff=0;ill=0; for(jj=0;jj<=me.m;jj++){if(me.pp[jj].d[0]==1)data[jj]=me.pp[jj].d[1];if(me.pp[jj].d[0]==2)data[jj]=me.pp[jj].d[1]+10;if(me.pp[jj].d[0]==3)data[jj]=me.pp[jj].d[1]+20;if(me.pp[jj].d[0]==4)data[jj]=me.pp[jj].d[1]+30;}if(logo==2)w=logoo+10;if(logo==3)w=logoo+20;if(logo==4)w=logoo+30;data[computer.m+1]=w;for(mm=0;mm<=computer.m;mm++)for(nn=mm;nn<=computer.m;nn++)if(data[mm]>data[nn+1]){tpp=data[mm];data[mm]=data[nn+1];data[nn+1]=tpp;}lp=0;while(lp<=computer.m){ if(data[lp]<10)pw[ww++]=data[lp];if(data[lp]>10 && data[lp]<20)pi[ii++]=data[lp];if(data[lp]>30 && data[lp]<38)pf[ff++]=data[lp];lp++;}if(ww==2)istwo(pw);else if(ww==3)isthree(pw,ww);else if(ww==5)/*pw[5]原始牌数组，假设已经升序排列*//*test[3]用来放置测试牌的数组*/for(i=0;i<4;i++){for(j=0;j<2;j++){test[j]=pw[i+j];}if(istwo(test)){ ill=0;for(kl=0;kl<5;kl++) /*把不在test数组中的三张放到test数组中*/ {if(kl==i){kl=kl+2;if(kl==5)break;}test[ill++]=pw[kl];}isthree(test);}}else if(ww==6)isthree(pw,ww);else if(ww==8)for(i=0;i<7;i++){for(j=0;j<2;j++){test[j]=pw[i+j];}if(istwo(test)){ ill=0;for(kl=0;kl<8;kl++) /*把不在test数组中的六张放到test数组中*/if(kl==8)break;}test[ill++]=pw[kl];}isthree(test,ww-2);}}else if(ww==9)isthree(pw,ww);else if(ww==11)for(i=0;i<10;i++){for(j=0;j<2;j++){test[j]=pw[i+j];}if(istwo(test)){ ill=0;for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/ {if(kl==i){kl=kl+2;if(kl==11)break;}test[ill++]=pw[kl];}isthree(test,ww-2);}}else if(ww=12)isthree(pw,ww);else if(ww=14)for(i=0;i<13;i++){for(j=0;j<2;j++){test[j]=pw[i+j];}if(istwo(test)){ ill=0;for(kl=0;kl<11;kl++) /*把不在test数组中的九张放到test数组中*/ {if(kl==i){kl=kl+2;if(kl==14)break;}test[ill++]=pw[kl];}isthree(test,ww-2);。
《C语言程序设计（第五版）》习题答案
《C语⾔程序设计（第五版）》习题答案各章习题参考答案第1章习题参考答案1. 简述C程序的结构特点。
答：(1) ⼀个C语⾔源程序由⼀个或多个源⽂件组成。
每个源⽂件由⼀个或多个函数构成，其中有且仅有⼀个主函数(main函数)。
(2) ⼀个函数由函数⾸部(即函数的第⼀⾏)和函数体(即函数⾸部下⾯的⼤括号内的部分)组成。
函数⾸部包括函数类型、函数名和放在圆括号内的若⼲个参数。
函数体由声明部分和执⾏部分组成。
(3) C程序书写格式⾃由，⼀⾏内可以写多条语句，⼀个语句也可以分写在多⾏中，每个语句必须以分号结尾。
(4)程序的注释内容放在“/*”和“*/之”间，在‘/’和‘*’之间不允许有空格；注释部分允许出现在程序中的任何位置处。
2. 分析例1.3程序的结构。
答：下⾯是例1.3的程序，它的结构是：有且只有⼀个主函数main以及若⼲个其它函数，还有⼀个被主函数调⽤的sumab函数。
函数有⾸部，包括类型和名称，⾸部下的⼤括号中有变量定义、输⼊、计算和输出等语句。
#includeint sumab (int x, int y); /*函数声明*/int main () /*主函数*/{ int a,b,sum; /*定义变量*/printf("请输⼊变量a与b的值:"); /*提⽰信息*/scanf ("%d %d", &a, &b); /*输⼊变量a和b的值*/sum=sumab(a,b); /*调⽤sumab函数*/printf("a与b的和等于%d", sum)；/*输出sum的值*/return 0;}int sumab (int x, int y) /*定义sumab函数，并定义形参x、y */{ int z;z=x+y;return z;}3. 分别编写完成如下任务的程序，然后上机编译、连接并运⾏。
(1) 输出两⾏字符，第1⾏是“The computer is our good friends!”，第2⾏是“We learnC language.”。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言程序设计<一>1、程序运行从main()函数开始，也从main()函数结束。
2、函数是C程序的基本单位，由函数头和函数体组成。
3、C语言源程序是由函数组成，它们的数目可以有多个。
4、在C语言源程序中，是必须有一个函数名为main的函数。
main()后的小括号()没有任何内容，它不可以省略。
5、C程序中的语句用分号结束，在一个程序行上可以有多个语句，一个C 语句能写在多个程序行上。
6、函数体是由一对大括号围起来语句序列组成。
小括号是函数的标志。
二、C语言的组成元素1、命令、函数和变量等是组成程序的基本对象，每一个程序对象都需要一个名字来标识，程序对象的名称就是标识符。
2、在C语言中，标识符分为用户标识符和系统标识符。
3、用户标识符是指在程序中由程序员为变量、函数、数组等程序对象自行命名的标识符。
4、系统标识符是指C语言编译系统内部预定义的用于表示命令数据内型的标识符，又称保留字符。
5、基本字符集英文字母:a~z和A~Z。
阿拉伯数字:0~9。
其他字符:（）、[ ]、+、-、*、/、%、<、>、<=、>=、==、！=、！、&&、‖、++、--、+=、-=、*=、/=、%=。
它们是由1~2个字符组成。
用作C语言的运算符；还包括:空格、换行符，回车符，单双引号，大括号，逗号，分号，反斜线，它们在程序中起到分隔和定界作用。
6、标识符:是用于标识命令；变量、函数，数组，数据类型等程序对象名称的字符序列。
7、组成标识符的合法字符有:字母，数字，下划线，三种，数字不能作首字符。
三、执行C语言程序1、单击“开始”——“程序”——“附件”——“命令提示符”。
2、按功能键<10>激活菜单，执行“File”——“NEW”（ALT+回车）全屏。
3、<F2>为保存，输入程序文件名。
4、<Ctrl>+<F9>运行有输入:等待输入→回车通过无输入:返回到编辑未通过:回车→F6→修改F3（打开）<二>一、对数据进行分类二、正确书写C语言中常量1、表示形式:小数形式:只有一个小数点，两边至少一边有数字。
2、指数形式:（科学计数法）e（E）的前后都有数字，e后的数字必须为整数。
3、转义字符:以反斜线（”\”）开头的字符序列人表示一个字符。
4、字符常量:是用单引号（``）括起的一个字符列外，它仍表示一个字符。
5、字符串常量:是双引号（” ”）括起的字符序列（可以是转义字符）。
6、定义符号常量:一般格式:#define 标识符常量三、在程序中使用变量1、概念:变量是在程序运行过程中其值可发生变化的数据对象。
2、组成:变量包括:变量名，数据类型、变量值。
3、变量名是一个合法的用户自定义标识符，是对对应内存单元的符号化地址，通过” & 变量名”的形式可获得该变量所对应内存单元中存储的数据值（物理地址）。
4、在程序中使用变量必须先定义后使用，使用前置初值。
5、定义变量要指出类型和名称，其一般格式为:类型标识符、变量名列表。
6、符号” = ”的作用是给变量賦初值，称赋值号。
赋值号把它右边的值赋值给它左边的变量。
7、未赋值变量其值不确定，不能参加运算，所以参加运算前要设置它的初始值。
8、类型标识符: 类型名称，如int ，float，char等，变量名列表是用逗号” ，”分隔。
9、为变量预置初始值有:初始化和赋初值两种，变量初始化是在定义变量后，在使用之前的赋值操作。
初始化:int x=1，y=2，z=3；(再同一语句行上)赋初值:int x，y，z；x=1；y=2；z=3；(不再同一语句行上)<三>一、计算算术表达式的值1、运算符:用来特定的符号来表示具体操作。
2、“ /” 名称除号，操作数2个，任意类型，运算规则:如果两个操作数为整数，商为整数（舍弃小数部分，不进行四舍五入；只要其一为实数，商为实型，6位小数）。
3、取模运算（“%”）必须为整数；模的符号和被除数符号相同；被除数小于除数，模等于被除数。
4、表示:用运算符将操作数连接起来组成的句子。
5、优先级:是指在表达式中运算符执行的先后。
6、结合性:是操作数于运算符结合的方向，左结合、右结合。
做结合是:指从左向右结合执行运算；右结合是:指从右向左结合执行运算。
7、强制转换:通过类型转换运算符来将表达式值的类型转换为所需的数据类型，一般格式（类型标识符）表达式如:（int）fv的值为int 型，（float）x/y是把x的转换成实型后再除以y。
二、给变量赋值1、赋值操作的本质是:向变量对应内存单元写入数据既改变变量的。
变化遵守“新来旧去”的原则，未重新赋值的变量保持它原来的。
三、计算自增自减表达式的1、确定自增自减运算表达式的简单方法是:观察表达式中变量和运算的位置关系，凡变量在前，则表达式值为变量自增（或自减）之前的值；凡变量在后，则表达式的值为变量自增（或自减）之后的值。
2、自增自减运算操作中包含有赋值操作，因此，不能对常量和表达式进行自增自减运算。
3、不论是前缀形式还是后缀形式的自增自减表达式执行后，对变量的影响都是相同，区别仅在表达式不同。
四、比较两个数的大小1、任何C语言表达式结果都可以视为逻辑值。
非“0”值为真，“0”值为假。
2、字符串不能直接用关系运算符进行大小关系比较运算。
3、数值数据（整型和实型）按数值大小进行比较，字符以它的ASCLL码大小进行比较。
4、高优先级组:>、>=、<、<=。
低优先级组:==、！=。
5、关系运算符的结合性为左结合。
五、表达复杂的条件1、形如A&&B&&C用&&连接成的串联表达式，如果表达式A为假，则不再计算表达式B和C，以此类推。
2、形如A‖B‖C用‖连接成的串联表达式，如果表达式A为真，则不再计算表达式B和C，以此类推。
3、逻辑运算符的优先级由高到低的顺序是:！→&&→‖4、逻辑表达式结果为真，sh值为1；结果为假其值为0。
六、计算逗号表达式1、从左向右依次计算各子表达式的值，然后取最右边表达式的。
2、常量和变量也可成为表达式，它们是表达式的特例。
3、逗号表达式的一般格式为: 表达式1，表达式2，表达式3；...<四>一、为程序输入数据1、在输入数据时，数据都是以字符的形式输入的，经过格式转换说明符转换成对应数据类型了类型；分隔非字符型数据的字符有:空格、水平制表符、换行符，它们统称为空白字符。
2、多个字符变量输入数据时格式控制串中没有使用任何普通字符，则输入字符时不使用任何分隔符。
3、scanf（格式控制串，变量地址列表）；参数用逗号分隔；格式控制串由一个%和一个字母组成，被称为格式转换说明符:%d（整型）int、%f（实型）float，double、%c（字符型）char。
4、scanf（）函数工作过程:扫描格式控制串，遇到格式转换说明符时，把键盘输入转换相对应类型数据存入对应地址所指的变量中，遇到普通字符则要原样输。
二、输出程序中的数据1、在printf（）函数的格式控制串中出现的普通字符将原样输出到显示器屏幕上。
2、%s格式转换符用于输出字符串。
3、实数在输出时，printf（）函数自动保留6位小数，不足补0，超过四十五入。
4、输出函数printf（）的一般格式:printf（格式控制串，数据项列表）；格式串由格式转换说明符和普通字符组。
5、printf（）函数工作扫描格式串，遇到格式转换说明符时，把对应的数据项按指定的格式输出；遇到普通字符则原样输出。
6、在格式字符d前加L用于输出long型数据。
<五>算法的表示一、C语言语句类别于作用1、说明语句:用于定义变量或声明函数。
（在函数体最前面，集中说明）2、表达式语句:在表达式后加上分号，它的功能是完成运算，有用的表达式语句能够在执行后改变变量的值。
3、空语句:单独的一个分号。
4、函数调用语句:用于实现对函数的调用。
变量名=函数名（实参表）；ch=getchar（）；5、块语句:用花括号括起的多条语句。
6、控制语句:由控制命令和被控制的语句组成，实现流程控制。
常用的有if、switch、while、for、break、retrun、continue等。
二、流程图符号表示的操作开始→输入x→x<0→y_→x=-x→输出x的绝对值→结束三、结构化程序的基本结构1、顺序结构:按语句先后顺序依次执行，没有执行不到的语句，每天语句只执行一次。
2、分支结构（选择）:if或switch（根据条件真假来选择执行语句）。
3、特点:只有一个入口；只有一个出口；结构的每部分都有机会被执行；不存在死循环。
4、模块化程序设计要在软件设计开始时把待开发的系统划分成若干相互独立的，简单容易实现的子系统。
这种方法被称为“自顶而下逐步细化”的程序设计分析方法。
5、程序设计的一般步骤:分析问题——确定算法→编写程序→→调试程序<六>、程序流程控制一、顺序结构程序的执行特点1、顺序结构程序的执行特点是:按照语句在程序中排列的先后顺序依次执行。
2、顺序结构程序中的每一条语句必须执行且只能执行一次，没有执行不到或重复执行的语句。
3、过程:①认真读题；②预编命令；③确定变量类型；④有无数据输入（赋值）；⑤核心语句:①输入；②赋初值；③运算；⑥输出。
二、设计顺序结构1、交换a、b两个变量的关键代码是:t=a；a=b；a=t；也可以不使用中间变量来完成，关键代码是:a=a+b；b=a-b；a=a-b；3、字母大小写转换:大写字母=小写字母-32；反之，小写字母=大写字母+32。
4、分离一个3位的整数x的个十百位上的数字的关键代码:d0=x%10；d1=x/10%10；d2=x/100；算法:把每一位上的数字当做个位去求:y=x%10（求个位）改变被除数（缩小10倍）；x=x/10（求被除数）<七>分支结构一、分支流程控制语句if语句1、分之结构程序中有两个或两个以上的执行路径，每个执行路径称为一个分支。
在执行时，根据分支条件选择执行一条，其它分支忽略。
2、C语言使用if命令和switch命令来实现程序的分支流程控制。
3、执行过程:如果表达式的值为真（不为0），执行语句；if下只能控制一条语句。
否则跳过语句。
如:输x绝对值。
#include“stdio.h”main（）{ int x；scanf（“%d”，&x）；if（x<0）x=-x；elsex=x；printf（“%d\n”，x）；}4、if...else语句一般格式:if（表达式）语句1else语句25、执行过程:先计算if后“表达式”判断值为真假，如为真执行“语句1”，否则执行“语句2”。