Ⅰ c语言，表达式书写规则问题
④、y=z%x不对，取余的两边必须都是整数，而z是实型的!②、x+y=z不对，赋值表达式左边是变量，不能是表达式！①、z=（y+x）；x++这个书写有没有错误啊？是不是中间少个分号？③、y=ch+x这个是可以的，因为字符型的都是按ASCII码存放的，运算时也是ASCII码！
Ⅱ 求C语言编写的一般格式
1，C语言程序的结构特点
一个C语言程序通常由一个预处理语句开始，如#include〉stdio.h〉,它表示,在编译语言程序前,用指明的文件取代改预处理语句,通常文件名是带有后缀为.h的磁盘文件.编译时,它将从磁盘中读出并插入到原来的预处理程序语句中.即预处理语句被指明的包含文件(头文件)代替.
头文件通常是在程序中被调用函数的说明语句和该函数用到的一些符号常量的宏定义.如在程序中经常调用一些标准库函数时,系统提供了相应的头文件,他们其中的一些内容是对该函数的说明及该函数用到的符号常量的宏定义等,如对fgets()的说明放在头文件stdio.h中,再盖头文件包含了对fgets()函数的说明:
char *fgets(char *s,int n,FILE *stream)
对符号常量的定义:
#define NULL 0
当然还包含了一些其他的标准I/O函数的说明和宏定义等.用户也可以建立自己的头文件,在程序开头用include进行包含就行了:
#include"文件名"
注意此时用" "符号来包括,它与 #include〉文件名〉的区别是查找的路径不同.前者表示现在当前目录中查找该文件,如果找不到,再到系统指定的目录中查找.而后者只在系统的制定目录中查找(一般是include\目录),若找不到,便报错.所以用#include"文件名"的形式常用于用户自己写的包含文件,他们通常放在和用户程序同一个目录下.当然在这种形式中,文件名也可用文件路径代替,这时,编译器就去用户指定的目录去查找包含文件.文件包含也可以用在程序行中,如:
main()
{
...
#include "myc.c"
...
}
其中myc.c时用户的c文件,编译时,它将从磁盘中取出,插入到该位置处.
一些在程序中常用到的常量也用编译预处理命令#define来定义,如在真假判断时,常用符号常量TURE和FALSE表示真和假,这时可以用一下定义:
#define TURE 1
#define FALSE 0
将以上代码写在程序的开头,编译时在程序中出现TURE的地方都用1代替,出现FALSE的地方用0代替.
一个完整的C程序,总是由main()函数开始,它像一个大型乐曲的引子,由此引出许多乐章(执行不同的功能的函数);main()函数又像一个大型建筑的框架,它显示了要完成这个建筑的轮廓,这些轮廓就是由一个个函数调用勾画出来的.因此可以说一个C程序是由一个个的模块堆砌起来的,这些模块的最小元素是函数.当然,模块也可以是一个源程序,它又有许多的函数组成.所以c程序的设计是一种模块化的设计,是许多的函数的堆砌.因此在应用程序的设计中,应将一个个的功能用一个个的函数来实现.下面就谈谈函数的使用.
turbo C的函数的使用
Turbo C2.0提供了400多个标准的库函数,每个函数都完成一定的功能.当程序执行这些功能时,只要调用这些函数即可,用户不必再自己写这些函数了.这些库函数包括输入输出函数,数学函数,字符串处理函数,内存函数,与BIOS和Dos有关的接口函数,屏幕函数和图形函数,过程控制函数和目录函数等.这些函数在我的主页上都能查到,欢迎来查询.
当标准库函数中没有用户要用的函数时,就必须自己设计了,设计函数的原则是:
1,函数不应处理太多的功能,要保持函数的小型化,功能单一化.
2,一个函数要保持自己的独立性,如同一个黑匣子一样,有进有出.
3,在函数中多使用复合语句,使函数也具有结构化,并且可以提高执行效率和节省存储空间.
4,在主函数前,要罗列出所有使用自定义函数的原型说明,这有利于在大型程序设计中追踪要调用的函数设置是 否正确.
5,在程序适当的地方加入注释(用/*...*/包含的语句)这便于程序的阅读和调试.
6,采用层次的书写程序格式,按程序的不同功能分层次.
这样一个函数编译后,其内部定义的程序代码与数据与另一个函数的程序代码和数据不会相互影响,因此在函数中要使用局部变量,即它的生存期指维持在调用该函数并执行时,也就是说函数被激活时.要尽量少用或不用全局变量,它将破坏函数的独立性.函数的这种设计方法类似于面向对象设计方法中的封装性.
C大型软件程序的设计步骤
C语言作为结构化的程序设计语言,易采用自顶向下的设计方法,即开始咱不涉及问题的实质和具体的解决步骤,而只是从问题的全局出发,给出一个概括性的抽象描述.例如编写一个信号处理程序,它要求对信号数据经过数字处理后进行图形显示并存盘.因而程序大轮廓应该是:
1,信号数据的输入
2,信号预处理
3,信号进行数字处理
4,进行显示
5,进行存盘
接着对各项功能进行细分,例如对于信号的输入,又可分为:
1.通过com1或com2由RS-232接口进行输入
2.由磁盘数据文件输入
对信号预处理又可分为:
1.对信号进行反序排列
2.用窗函数预处理
对数字处理又可分为:
1.求快速傅立叶变换
2.求功率谱
对用窗函数处理又可分为:
1.海明窗处理函数
2.汉宁窗处理
3.布拉格曼窗处理
其他功能依此类推.
在此细化的基础上再进行细化,以至于成为一个个单独的功能,便于用一个个函数来实现.
下面就是设计一个个函数的实质性阶段.要定义变量,要选区标准函数,要确定算法,这是构造程序的基本单元.当一个个函数都设计完了以后,便可将这些函数在主函数中堆砌起来,并用主函数做总控程序,完成对他们的参数传递,控制选择对这些函数的调用,形成一个完整的实用的信号处理程序.
大程序的设计风格
当一个程序较大时,可将一个程序分成几个部分,每一个部分可单独编成一个源文件,这些源文件可进行单独编译成.obj文件,然后将这些文件组合成一个较大的程序.通常可采用如下方法:
1.include方法
例如,一个程序分成两个源文件,既由a1.c和a2.c两个源程序组成,这时候可将a1.c写成:
#include〉stdio.h〉
#include"a2.c"
main()
{
...
strcpy(s1,s2);
a2();
...
}
而a2.c可写成:
#include〉string.h〉
void a2()
{
....
}
然后在制作一个project文件,内容为:a1.c a2.c
设这个工程文件名为:a1.prj,其中文件中各文件名的后缀可省略,先后顺序也无关,它只影响编译时的顺序.者可在Turbo c的编辑状态下写成,并存盘为a2.prj文件.然后用Alt+p选择Project菜单中的Project_name项,填写生成的a1.prj文件名.然后按F9,即可生成a1.exe可执行文件.
当用汇编语言与C语言混合编程时,则要将汇编语言子程序单独编译生成.obj文件,然后制作工程文件,再进行对C程序的编译和连接.关于这方面的介绍可参考Turbo c2.0的命令行编译.
若程序还需要一些其他的被编译的程序或库文件,这些文件时C语言的标准库不能提供的,则也可将它们的名字放在Project文件中.如:
mymain
myfunc
secial.obj
other.lib
当用F9进行编译连接时,对后缀为.obj的文件只进行连接,对后缀为.lib的库文件不会进行编译,只是进行连接,这样当进行外部调用时,就只会对库进行检索.
当多个源文件制作成project 文件时,一个.c的源文件依赖于其他的.c源文件,若它们之间用一个头文件来进行接口,这时应用括号将这些头文件扩起来(头文件之间可用逗号,空格或分号间隔),这样一旦头文件改变时,它们将被重新编译,例如:有一个主程序名为mymian.c,它包含头文件为:myfuncs.h,而另一个文件是myfuncs.c
这样当project文件的内容写成如下形势时:
mymain.c(myfuncs.h)
myfuncs.c(myfuncs.h)
若一旦myfuncs.h被修改,则对该project文件进行编译时,mymain.c及myfuncs.h将被重新编译
Ⅲ C语言书写格式标准是什么
你的错误是没加头文件，因为使用printf需要调用库函数 stdio.h。
符号名包括模块名、常量名、标号名、子程序名等。这些名字应该能反映它所代表的实际东西，具有一定的意义，使其能够见名知义，有助于对程序功能的理解。命名采用匈牙利命名法。具体规则如下：
(1)所有宏定义、枚举常数和const变量，用大写字母命名。在复合词里用下划线隔开每个词。
(2)复合词中每个单词的第一个字母大写。除了规则5.1.1.1以外，避免使用下划线。
(3)类、类型定义和枚举型名的第一个字母大写。
(4)函数名是复合词的，第一个词采用全部小写，随后每个单词采用第一个字母大写，其它字母小写方式；如果是单个词的，采用全部小写方式。
(5)循环变量可采用i, j, k等，不受上述规则限制。
(6) 类的成员变量应采用m_开头。
(7) 全局变量词头为g_ 。
(8) 临时变量词头为tmp_ 。
(9) 对结构体内的变量命名, 遵循变量的具体含义命名原则
(10)用小写字母的前缀表示变量的类型，前缀的下一个字母用大写。
——文件之中不得存在无规则的空行，比如说连续十个空行。
一般来讲函数与函数之间的空行为2-3行；
在函数体内部，在逻辑上独立的两个函数块可适当空行，一般为1-2行。
——程序编写首先应考虑清晰性，不要刻意追求技巧性而使得程序难以理解。
——每行长度尽量避免超过屏幕宽度，应不超过80个字符。
——除非对效率有特殊要求，编写程序要作到清晰第一，效率第二。
——尽可能使用函数库。
——尽量用公共过程或子程序去代替重复的功能代码段。要注意，这个代码应具有一个独立的功能，不要只因代码形式一样便将其抽出组成一个公共过程或子程序。
——使用括号清晰地表达算术表达式和逻辑表达式的运算顺序。如将 x=a*b/c*d 写成 x=(a*b/c)*d可避免阅读者误解为x=(a*b)/(c*d)。
——避免不必要的转移。
——避免采用过于复杂的条件测试。
——避免过多的循环嵌套和条件嵌套。
——建议不要使?*=，^=, /=等运算符。
——一个函数不要超过200行。一个文件应避免超过2000行。
——尽量避免使用go to语句。
——避免采用多赋值语句，如x = y = z ;
——不鼓励采用?:操作符，如z = (a>b)?a:b;
——不要使用空的if else 语句。
Ⅳ C语言程序设计基础概念
C语言程序设计基础概念
C语言是近年来非常流行的语言，很多人宁愿放弃已经熟悉的其他语言而改用C语言，其原因是C语言有优于其他语言的一系列特点。下面是我搜集的C语言程序设计基础概念，希望大家认真复习!
1.1 C语言的特点
C语言是近年来非常流行的语言，很多人宁愿放弃已经熟悉的其他语言而改用C语言，其原因是C语言有优于其他语言的一系列特点。下面是C语言的主要特点：
(1)语言简洁、紧凑，并且使用方便、灵活;
(2)运算符丰富;
(3)数据结构丰富;
(4)具有结构化的控制语句;
(5)语法限制不太严格，使程序设计比较自由;
(6)C语言允许用户直接访问物理地址，能进行位(bit)操作，可以直接对硬件进行操作。
1.2 源程序的书写规则
C语言的书写规则。C语言书写格式自由，一行内可以写几个语句，一个语句也可以分写在多行上。C程序没有行号，每个语句和数据定义的.最后必须有一个分号。C语言中分号是语句中不可少的，即使是程序中的最后一个语句也应该包含分号。C语言中的注释可以用〃/*〃用〃*/〃结束，注释可以在任何允许插入空格符地方插入。C语言中注释不允许嵌套，注释可以用西文，也可以用中文。
1.3 C语言的风格
由于C语言对语法限制不太严格，为了保证程序的准确性和可读性，建议在书写程序采用阶梯缩进格式。也就是按如下格式书写C语言程序：
**********;
*****()
{
**********;
********;
{
******;
……
}
*********;
}
概括起来，C语言程序具有如下的风格：
①C语言程序的函数具体模块结构风格，使得程序整体结构清晰、层次清楚，为模块化程序设计提供了强有力的支持。
②C语言的源程序的扩展名都是.C。
③C语言中的注释格式为：
/*注释内容*/
/与*之间不允许有空格，注释部分允许出现在程序中的任何位置。
④C语言中的所有语句都必须以分号“;”结束。
;Ⅳ C程序书写格式自由,一个语句可以写在多行上吗
可以。
1、只要关键字不分行就行； 比如： if(a==b || a==c) 等价于 if( a==b || a==c ）。
2、在C语言中，注释可以加在程序中的任何位置。
Ⅵ C语言怎么写比较规范啊，比如下面两种写法，哪个才更标准一些呢，求大神指教！
C语言 在书写的时候
大括号的位置
函数和变量的命名规则
下划线的使用
大小写使用
空格的添加
这些 都有不同的规则
不过 到目前为止 没有一个通用的
都是各自规定
比如你这两个 大括号的写法 哪种都有人用 无所谓更规范。
如果没有要求 任何一种写法都可以
但不同公司要求不同的
Ⅶ c程序在书写时有严格的缩进要求否则不能编译通过
所有的C语言编译器是没有这样的规定的。C语言本身是一种非常灵活的编程语言，包括它的书写格式和语法表达。C语言每一个语句都是以“；”结束，只要遵循这个原则即可，并没有强制要求必须以缩进方式编写程序，也不影响程序的编译。通常以缩进方式编写程序是一种比较提倡的好的习惯和做法，有利于对程序的理解和检查。
Ⅷ C语言的书写规则主要有哪些呢
1.
1.1符号命名规则
1.1.1符号名包括模块名、常量名、标号名、子程序名等。这些名字应该能反映它所代表的实际东西，具有一定的意义，使其能够见名知义，有助于对程序功能的理解。命名采用匈牙利命名法。规则如下：
(1)所有宏定义、枚举常数和const变量，用大写字母命名。在复合词里用下划线隔开每个词。
(2)复合词中每个单词的第一个字母大写。除了规则5.1.1.1以外，避免使用下划线。
(3)类、类型定义和枚举型名的第一个字母大写。
(4)函数名是复合词的，第一个词采用全部小写，随后每个单词采用第一个字母大写，其它字母小写方式；如果是单个词的，采用全部小写方式。
(5)循环变量可采用i, j, k等，不受上述规则限制。
(6) 类的成员变量应采用m_开头。
(7) 全局变量词头为g_ 。
(8) 临时变量词头为tmp_ 。
(9) 对结构体内的变量命名, 遵循变量的具体含义命名原则
(10)用小写字母的前缀表示变量的类型，前缀的下一个字母用大写。
表 1
词头 类型 词头 类型
ch char l long
i integer u unsigned
b boolean p pointer
f float lp long pointer
d double s string
st structure sz ASCII string
by byte n short int
H handle x,y 分别为x,y坐标
dw DWORD fn function
表 2
词头 变量名 词头 变量名
task task sig signal
sb binary semaphores wd watchdog
sm mutual exclusion tm timer
sc counting semaphores msg message
pipe pipe
例：
#define ARRAY_SIZE 24 /*规则5.1.1.1*/
int g_iFlag;
class MyClass /*规则5.1.1.3*/
{
};
void someFunc( ) /*规则5.1.1.2和5.1.1.4*/
{
int nArray[ARRAY_SIZE];
unsigned char uchByte;
char szName[ ];
char *pszName = szName;
}
(11)有些词头（如p和u）可以和其它词头组合。
例：WDOG_ID wdId;
WDOG_ID g_wdId; /*全局watchdog Id，故以g_开头*/
1.1.2名字的长度一般不要过长或过短。过长的名字会增加工作量，使程序逻辑流程变得模糊；过短的名字无法表达符号的实际意义。约定长度范围：3-31；
1.2数据和函数说明
1.2.1数据说明次序应当规范化，使数据属性容易查找，也有利于测试、排错和维护。说明的先后次序应固定，应按逻辑功能排序，逻辑功能块内建议采用下列顺序：整型说明、实型说明、字符说明、逻辑量说明。
1.2.2如果设计了一个复杂的数据结构，应当通过注释对其变量的含义、用途进行说明。
1.2.3在函数的声明中使用异常声明。
如：void f() throw(toobig, toosmall, divzero);
在声明一个函数时，将它所抛出的异常列出，便于函数的使用者了解可能会发生哪些异常。
1.3 程序注释
1.3.1程序注释是程序员与日后的程序读者之间通信的重要手段之一，注释分为文件注释、函数注释和功能注释。
1.3.2正规程序的注释应注意：
——注释行的数量占到整个源程序的1/3到1/2。
1.3.3文件注释位于整个源程序的最开始部分，注释后空两行开始程序正文。它包括：
——程序标题。
——目的、功能说明。
——文件作者、最后修改日期等说明。
例：
./********************************************************************
（空一行）
标题: Demo.c
功能: 测试VxWorks的各种系统调用.
说明:
该程序测试各种VxWorks的系统调用函数。包括任务（taks）的创建、挂起及任务间通过信号灯实现同步，通过消息队列 进行通讯。
程序创建了两个任务：一个高优先级的任务和一个低优先级的任务。两个任务间通过一个二进制的信号灯进行同步，通过消息队列进行通讯。
当前版本： x.x
修改信息： 2000.06.05 John， Initial Version
2000.07.05 Tom， Bug xxxx fixed
**************************************************************/
(空2行，开始程序正文)
1.3.4 函数注释通常置于每函数或过程的开头部分，它应当给出函数或过程的整体说明对于理解程序本身具有引导作用。一般包括如下条目：
——模块标题。
——有关本模块功能和目的的说明。
——调用格式
——接口说明：包括输入、输出、返回值、异常。
——算法。如果模块中采用了一些复杂的算法。
例：
file://（/注释开头应和上一函数空两行）
（注释开头与上一函数最后一行间隔两行）
/********************************************************************
标题：assignmentComplete
功能：BSC=>MSC消息生成函数，生成assignment_complete指配完成消息(BSMAP消息) .
格式：
int assignmentComplete(int iCellId, int iServiceChannnelNum, char *pszMSGData) throw(exception1, exception2)
输入：
int iCellId: MS所在的小区识别
iCellId取值：0x00-——0xff
int iServiceChannnelNum：MS所占的业务信道号码
输出：
char * pszMSGData：指配完成消息数据
返回值: 0x00正常
异常：exception1异常情况1, exception2异常情况2
********************************************************************/
( 注释后直接开始程序正文，不空行。)
1.3.5功能性注释嵌在源程序体中，用于描述其后的语句或程序段做什么工作，也就是解释下面要做什么，或是执行了下面的语句会怎么样。而不要解释下面怎么做，因为解释怎么做常常与程序本身是重复的。
例：
/*把 amount 加到 total中*/
total = amount + total;
这样的注释仅仅是重复了下面的程序，对于理解它的工作并没有什么作用。而下面的注释，有助于读者理解。
/*将每月的销售额amount加到年销售额total中*/
total = amount + total;
1.4 函数编写应尽可能短小精悍，一般不超过两屏，以便于调试和理解。
1.5语句结构
为保证语句结构的清晰和程序的可读性，在编写软件程序时应注意以下几个方面的问题：
——在一行内只写一条语句，并采用空格、空行和移行保证清楚的视觉效果。
——每一个嵌套的函数块，使用一个TAB缩进（可以设定为4个空格），大括号必须放在条件语句的下一行，单独成一行，便于匹对：
如，有一段程序如下：
for(i=1;i<n-1;i++){ t=1; for(j=i+1;j<n;j++){
if(a[j]<a[t] ) t=j; if(t!=i ){work=a[t];a[t]=a[I];a[I]=work;}}}
应写为
for( i=1; i<n-1; i++)
{
t=1;
for(j = i+1; j<n; j++)
{
if(a[i]<a[j])
t=j;
if(t!=1)
{ .5.
Q/ECC/BJ 010—2001
work=a[t];
a[t]=a[i];
a[i]=work;
}
}
}
——文件之中不得存在无规则的空行，比如说连续十个空行。
一般来讲函数与函数之间的空行为2-3行；
在函数体内部，在逻辑上独立的两个函数块可适当空行，一般为1-2行。
——程序编写首先应考虑清晰性，不要刻意追求技巧性而使得程序难以理解。
——每行长度尽量避免超过屏幕宽度，应不超过80个字符。
——除非对效率有特殊要求，编写程序要作到清晰第一，效率第二。
——尽可能使用函数库。
——尽量用公共过程或子程序去代替重复的功能代码段。要注意，这个代码应具有一个独立的功能，不要只因代码形式一样便将其抽出组成一个公共过程或子程序。
——使用括号清晰地表达算术表达式和逻辑表达式的运算顺序。如将 x=a*b/c*d 写成 x=(a*b/c)*d可避免阅读者误解为x=(a*b)/(c*d)。
——避免不必要的转移。
——避免采用过于复杂的条件测试。
——避免过多的循环嵌套和条件嵌套。
——建议不要使用 *=，^=, /=等运算符。
——一个函数不要超过200行。一个文件应避免超过2000行。
——尽量避免使用go to语句。
——避免采用多赋值语句，如x = y = z ;
——不鼓励采用?:操作符，如z = (a>b)?a:b;
——不要使用空的if else 语句。如
if(cMychar >= ‘A’)
if(cMychar <= ‘Z’)
printf(“This is a letter \n”);
else
printf(“This is not a letter \n”);
else到底是否定哪个if容易引起误解。可通过加{}避免误解。
——尽量减少使用“否定”条件的条件语句。如：
把 if( !( (cMychar<’0’) || (cMychar>’9’) ) )
改为if( (cMychar>=’0’) && (cMychar<=’9’)
Ⅸ C语言书写格式严格，要求一行内只能写一个语句，对吗
淡然不是啦 一行可以写好多句 比如
if(a==1){ a=1;b=2;c=3;d=a+b+c;printf("%d",d);}
这样是可以的 这样写只是不美观 不过你也可以把他（花括号里面的）理解为一个语句
Ⅹ 求助，关于c语言的。
C语言基础(01-引言及预备知识)： C语言是一门功能强大的编程语言，它也是C++语言的基础。C语言属于中级语言。这里所说的中级是相对于计算机的底层硬件而言的。汇编语言是最低级的语言，它可以直接与硬件打交道。高级语言有Pascal、Basic、Fortran等等。高级语言的一条语句对应低级语言的很多条语句，任何高级语言编写的程序都要经过编译程序的编译、连接才能成为可以运行的程序。编译连接的过程也就是把高级语言翻译成机器语言(二进制机器码)的过程，而汇编语言是基本上与机器语言一 一对应的一种语言。这个翻译过程是由编译程序自动完成的。把C语言定为中级语言是有它的道理的，因为C语言既有汇编语言的存取底层硬件的能力，又具有高级语言的许多特点。熟练掌握了C语言，学习其它的各种编程语言应该是很轻松的了。
C语言的书写格式：
1) 一个C语言编写的源程序，必定有一个主程序(称为main()函数，在C语言中子程序称为“函数”(当然，不要理解成为数学里面的“函数”)。但是决不能有一个以上的main函数(即只能有一个)。
2) 函数语句块用‘{’括号开始， 以‘}’反括号结束。这样的花括号必须成对出现。
3) 表达式写在小括号里面，以‘(’括号开始，以‘)’反括号结束。
4) 函数不能嵌套，即函数里面不能再套函数。(每一个函数是完成一个特定功能的函数模块)
C语言的组成：
C语言是由许多函数组成的。其中只有一个主函数(main()函数)。C程序执行时总是从main函数的‘{’处开始，至main函数的反大括号'}'处结束。当然还有其它一些规则，这将在以后的学习中去熟悉它。
C语言的书写规则：
C语言在书写时有它自身的特点：书写格式比较自由，在一行里可以写多条语句，一个语句也可以分写在多行上。虽然如此，在书写源程序时还是要注意哪些可以自由书写，而哪些必须要按照书写规则来书写。
几条规则写在下面：
1) 一行内可以写几个语句，建议一行不超过两条语句；
2) 一条语句可以写在多行上；
3) C语句不需要写行标号；
4) 每条语句及数据定义的后面要写上分号以表示该语句结束；
5) C语言中注释用 /* */来表示；
6) 建议书写时采用缩进格式；
7) 花括号、小括号都是成对出现的。
一个最简单的C程序的编写：
/* 程序代码*/ /* 注释部分*/
main() /*main是主函数名。紧跟在main后面的括号是放参数的。
括号里面为空说明main函数不需要参数*/
{ /*正写的大花括号表示main函数从这里开始*/
} /*反写的大花括号表示main函数到这里结束*/
说明：由于是一个演示程序，在函数体内并没有任何可以执行的语句，也就是这个程序什么事也不做。
这个程序就是这么简单： 写在一行上就是 main() { }
你在TC的编辑环境下把这段代码输入进去，按F9键编译连接，按CTRL_F5运行，一定很正常。但是什么结果也不会有，因为在main函数里面什么代码也没有。
下面再举一个可以向屏幕上输出一条信息的例子：
main()
{
printf("这就是C语言编写的程序!"); /*这一条语句的作用是向屏幕输出一条信息
”这就是C语言编写的程序!"*/
}
在这个程序中，main函数只有一条语句：printf("这就是C语言编写的程序!");这个语句的作用是向屏幕输出一个字符串。有关这个语句的知识以后再讲。现在要注意的是一个C语言程序的框架是怎样组成的。
C语言程序的几种文件格式：
1、 源程序---在TC集成环境中输入的程序文本称为源程序。源程序是一种文本文件。它是我们看得见并认识的一种文件。其扩展名为.C。例如你把文件保存为TEST，那么在磁盘上应看得到TEST.C这个文件。这样的文件可以用记事本打开。
2、二进制文件---写完了源程序后接着要做的是编译这个文件。在TC集成环境里是按ALT_F9键，编译后生成了一个二进制文件，这个二进制文件名为TEST.OBJ，也就是扩展名为OBJ的目标文件。
3、运行文件---最后一步是make(或Link)，在TC集成环境里是按F9键Make之后生成了一个可以在DOS下运行的文件，其扩展名为EXE。如TEST.EXE。这个EXE文件是由第2步中的OBJ文件生成的。OBJ文件虽然是二进制文件，而电脑又是可以运行二进制文件的，为什么还要把OBJ文件Link为EXE文件才能运行？这里的知识就比较多了，这里不能多讲。但是要明白一点，在DOS下仅仅有了一个二进制文件还不能运行，因为操作系统要把这些二进制文件加以规划，把相应的数据、程序代码放到应该放的内存位置，这样的经过严密规划和组织好了的二进制文件才能运行。而这些只有在生成的EXE文件里面才做完了这些工作。
---------------------------------------
作业题：
1、下列程序中格式错在( )处。
A. main() B. int a,b,z;
C. a=2:b=3; D. z=a+b;
分析：A,B,D 没有错误。 C 中在a=2后面应该是分号而不应是":"号
答： C
2、C语言允许将一条语句写在两行上，下列语句不正确的是
A. int a,
B;
B. int a
,b;
C. int
a,b
D. int a,b
;
分析：C语言规定可以在语句中的任何一个分隔符或空格处换行。上面4个选项中D.有问题因为在D.中第一行的最后没有分隔符，而第二行只有一个分号，可以看做一个语句。所以D中的错误为：第一行是一个独立的语句，但是少了一个分号。
答： D
3. C语言的一行写不下时，可以
A. 用逗号换行 B. 用分号换行
C. 在任意一空格处换行 D. 用回车符换行
分析：C语言可以在任何一个分隔符或空格处换行，所以此题的正确答案是 C
答： C
4. 下列程序段中，哪一个是错误的注释方法？
A. #in/*包含*/clude<stdio.h>
void main()
{
}
B. #include<stdio.h>
void main/* */(/*主函数*/)
{
}
C. #include<stdio.h>
void main()
{ int x/*初始化*/=10;
/*打印*/printf("%d",x);
}
D. #include<stdio.h>
void main()
{
int x=10;
printf("%d",x);
/*打印x的值*”*=10*/
}
分析：根据C语言的规定：注释不能插在标识符的中间，在其它有分隔符的地方都可以插入注释，上面四个程序段中只有A是将注释插入在标识符的中间了。所以A是错误的。
答： A
5. C语言程序是由( )组成的？
答：C程序是由函数组成的。
6. C程序运行时，运行的是什么文件？
数据的类型：
在程序中要处理大量的数据，把这些数据按其特点分为几种基本的数据类型，它们分别是：
1 、整型 2 、字符型 3 、实型
还有其它的一些扩展的数据类型，但是开始学习时要先熟悉这三种基本数据类型。
在 C 语言中这几种数据类型用符号表示如下：
整型数据类型 int /* 一般指可以运算的数，如自然数就是整型数据类型 */
字符数据类型 char /* 一般指文字，如英文字母；字符类型的 '1''2''3''4' 等 */
实型 float /* 也称作浮点型，记住 float 类型的数都是有小数位的，如 425.23*/
常量和变量：
常量――程序运行过程中其值不变的量，如一个整数 134, 一个字符 ‘a'
变量――程序运行过程中其值可以变化的量，如 int a; char b; 那么 a 和 b 都是变量。
符号常量 ――用一个“符号”来表示的一个“常量”称为“符号常量”。
符号常量有什么好处 ――在给符号常量命名的时候，按习惯取的名字与实际上的含义相符，可以“见名识意”；另外在需要修改常量的值的时候，只需要修改符号常量的定义部分即可，非常方便。
符号常量的定义方法 ―― #define 符号 常量
例： #define NUMBER 30 /* 定义了一个符号常量，在这里是用符号 NUMBER 表示整数 30 ，以后在程序里就可以
用符号 NUMBER 代替整数 30 进行运算 */
main()
{
int a=20; /* 把常量 20 赋给整型变量 a*/
int c; /* 定义了整型变量 c*/
c=NUMBER+a; /* 变量 c 的值此时为 50 ，符号常量 NUMBER 参与了运算 */
}
变量的定义方法 ――在变量的名字前面加上一个变量的数据类型，以说明已定义的变量可以用来存放什么样类型的数据。
例： int a; /* 定义了一个整型变量，以后这个变量只能存放整型类型的数 */
char b; /* 定义了一个字符型变量，以后这个变量只能存放符字符型数据 */
怎样把常量值赋给已定义了的变量 ――用一个 = 号赋值。
例： int a; /* 定义一个整型娈量 a*/
char b; /* 定义了一个字符型变量 b*/
a=20; /* 用 = 号完成赋值，赋值后变量 a 的值此时为 20*/
b='d' /* 把常量字符 'd' 赋给变量 b ，此时变量 b 的值是字符 'd'*/
变量赋值时一种更灵活的方法 ――可以在一行上给多个相同数据类型的变量赋值，变量之间用逗号分隔。
例： int a,b,c,d; /* 定义了 4 个整型变量 */
char e,f,g; /* 定义了 3 个字符型变量 */
深入理解变量 ―― 1 ） 1 个变量必须有一个变量名。 2 ）变量必须有其指定的数据类型
3 ）变量一旦被定义，它就在内存中占有一个位置，这个位置称做该 变量的地址 。
4 ）每一个变量都有其对应的值。
l 一定要牢记变量的这 4 个特性。
变量使用时的注意事项 ―― 1 ）变量在使用之前一定要先定义，使用一个没有定义的变量是错误的。
2 ）变量必须在一个函数的开始部分定义。（这个限制在 C++ 中不存在）
例题：写一个 2 个整数相加的程序。
/* 解题思路：求 2 个整数相加，必定要先定义 2 个变量来存放这 2 个数，另外还需要 1 个变量用来存放
相加的和，所以共需要定义 3 个整型变量 */
/* 注意每次在写 C 程序的时候一定要注意书写格式 */
main()
{
int a,b,c;
a=20,b=30; /* 在这里指定变量的值，因为还没有讲输入输出函数，只能这样了。 */
c=a+b;
}
想一想，这样简单的一个题，需要知道的知识面却不少。 用到了上面所讲的哪些知识？
C语言中的库函数――我们编写C语言程序时要写许多代码，这些代码是用基本程序语句如运算符、表达式、几种语句结构来组成。这些语句组成了多个不同的函数，由多个函数组成一个完整的程序。实际上如果程序中的语句都要由自己来写的话，那么工作量是很大的了。并且有一些完成基本任务的函数如输入输出函数是经常需要使用的。这样的一些常用的完成基本任务的函数有许多已经由提供编译程序的公司为我们写好了。这些已经写好的函数放在TC或者BC编译器的文件中。所谓“库函数”，就是存放“函数”的“仓库”。在TC中，函数的“仓库”在哪里呢？在TC的.\LIB目录中。编写程序的时候，如果我们需要使用某个库函数，就要在这个程序开头指明这库函数存放在哪里，以便让编译程序到这个地方去找。这个指明库函数路径的语句称为“包含”语句，写做#include。完整的写法是：
#include <stdio.h>
#include 是包含的意思，<stdio.h> 是指明要使用的库函数在 stdio.h这个文件里面有说明。尖括号<>是必须要写的。而实际上，编译程序在stdio.h之个文件里根据库函数名可以在.\LIB目录下的LIB文件里找到相关的代码，写进程序里面去。使用不同的库函数时要用不同的包含，关于怎样使用#include，可以查看库函数的帮助。
有了众多的库函数，给编写程序带来了很大的方便。就象做房子要用砖和瓦一样。如果没有砖和瓦，做房子自己要挖土烧砖，可想而知，那样做房子的难度有多大。写程序也是这样，有了库函数，在需要完成某些任务时，找到相应的库函数调用一下就可以了，不需要自己一点一点的写代码。在学习编程的同时要多多了解一些库函数的特点及用法，对编写程序是有很大的好处的。
（在Windows下编写程序，需要了解的“库函数”就更多了，可以说不了解库函数就不会编程。VC中用的是MFC，Win32中用的是API，它们都是函数库）
先了解二个库函数――1、scanf函数 /*格式化控制台输入函数*/
函数原型：int scanf(control_string....); /*看上去很复杂。没关系，以后自然会明白的*/
使用例：
void main()
{
int a,b,c; /*定义了三个整型变量*/
scanf("%d%d",&a,&b); /*从键盘输入二个整数到娈量a和b中*/
c=a+b; /*把变量a与b相加的和送给变量c*/
}
下面仔细讲一下scanf函数各参数的用法：
可以看到在小括号里有二个%d，后面有二个变量a和b。二个%d的写法为"%d%d"，注意凡是这样的符号都要写在双引号里面，而变量则写在双引号的外面并用逗号分隔。这个%d我们称为格式化说明符，第一个%d用于说明第一个变量a，第二个%d用于说明第二个变量b，这样的顺序是一一对应的。%d格式符说明了后面输入的变量值是整型数。
另外注意的是二个%d是靠在一起的 %d%d，凡是这样的写法，在输入数时，对于二个数之间的分隔是用“空隔键”来实现的。如输入30和50这二个数形式为 30 50 如果二个%d写成%d，%d中间有一个逗号，那么在输入数据时也一定要在输入的数之间加上逗号，如 30，50。
再来看一下变量的写法，可以看到在每一个变量名的前面都有一个&号，这个&号是取变量地址的意思，那么&a写在一起就是变量a的地址，&b写在一起就是变量b的地址。
上面的scanf函数的作用就是把从键盘上输入的二个整数分别送到变量a和变量b的地址里面去。这个&号是非常重要，不要写漏了。
scanf函数的格式说明符（格式说明符说明了下一步将读的是什么类型的数据）
格式码 含义
%c 读一单字符
%d 读一整数
%i 读一个浮点数
%e 读一个浮点数
%f 读一个浮点数
%g 读一个浮点数
%o 读一个八进制数
%s 读一字符串
%x 读一十六进制数
%p 读一指针
%n 读一个指针收一个等于到目前为止输入的字符数止的整数
%u 读一无符号整数
%[] 扫描一字符集
例：从键盘输入二个字符，一个大写，一个小写，然后把这个小写字符转换成大写，大写字符转换成小写。
#include<stdio.h> /*因为在程序里用到了库函数scanf，所以要使用包含#include<stdio.h>*/
void main()
{
char ch,chh; /*定义了二个字符型变量*/
scanf("%c%c",&ch,&chh); /*从键盘输入二个字符，一个大写，另一个小写*/
ch=ch+32; /*大写转成小写*/
chh=chh-32; /*小写转成大写*/
}
2、printf函数 /*格式化输出函数*/
函数原型：int printf(const char *control_string....);
说明：printf把变量的值或常量字符串输出到控制台（一般是显示屏）
使用例：
#include<stdio.h>
void main()
{
int a,b,c;
scanf("%d%d",&a,&b);
c=a+b;
printf("输出二个整数相加的和"); /*输出字符串常量，这里没有用到格式化说明符*/
printf("%d",c); /*把变量c的值用整型格式输出，这里%d是整型格式说明符*/
}
如果有几个变量的值要输出，用这样的形式：printf("%d %d %d",a,b,c);
从这个printf输出的格式中看出，每一个格式符对应一个变量，其对应顺序也是一一对应的，第一个%d对应第一个变量a，以此类推。注意在printf函数中，变量前面就不要加&符号了。
注意printf函数中几个%d之间留了一些空格，这里的用法与scanf相比有一点不同。在printf函数中格式符之间留多少空隔，输出的时候每一个输出的值之间就有多少空隔。如printf("%d %d %d",a,b,c);输出则为：20 30 50 (这里的数是假设的）。如果写为printf("%d，%d，%d",a,b,c);则输出形式为 20，30，50
printf函数的格式符：
格式码 格式
%c 单个字符
%d 十进制数
%i 十进制数
%e 科学法表示
%E 科学法表示
%f 十进制浮点数
%g 用%e或%f中较短的的一个（如果是%e,用小写e）
%G 用%e或%f中较短的的一个（如果是%E,用大写E）
%o 以八进制形式输出
%s 字符串
%u 无符号十进制数
%x 十六进制数（小写）
%X 十六进制数（大写）
%p 显示一个指针
%n 相关变量是整型指针，它所指处存放至今要写入字符的总数
%% 打印一个%号
printf函数使用例：
1）char ss="abcdefghijk"; printf("%s",ss); /*输出一个字符串，屏幕上显示"abcdefghijk"*/
2）unsigned int a=65535; printf("%u",a); /*以十六进制形式输出一个无符号数，显示为ffff*/
3）int a=123,b=456,c=687; printf("%d\t%d\n%d",a,b,c);
输出形式为：
123 456 /*'\t'是一个制表符，所以要移动一个制表位这么多空格数*/
687 /*'\n'是换行转义符，在前面字符常量里讲过。所以要换一行再输出687*/
C语言基础(05-运算符和表达式)：运算符（也叫操作符）－－运算符是一个表示特定的数学或逻辑操作的符号。如'+'号，表示了一个相加运算；'&&'号表示了一个逻辑‘与’的运算。由运算符把需要进行运算的各个量（常量或变量）连接起来组成一个表达式。
下面要讲的是标准的运算符，在C＋＋中还有另外的一些运算符。运算符 进行的运算 所属类别 备注
[ ] 间隔符 标点符号
( ) 间隔符 标点符号
· 直接分量选择 双目操作符
-> 间接分量选择 双目操作符
++ 前增量、后增量 单目操作符
-- 前减量、后减量 单目操作符
+ 加 双目操作符、单目操作符
- 减 双目操作符、单目操作符
* 1）乘 2）间接引用 双目操作符、单目操作符
/ 除 双目操作符
% 求余 双目操作符
& 1）位‘与’2）取地址 双目操作符、单目操作符
! 逻辑‘非’ 单目操作符
&& 逻辑‘与’ 双目操作符
|| 逻辑‘或’ 双目操作符
<< 左移位 双目操作符
>> 右移位 双目操作符
< 小于 双目操作符
> 大于 双目操作符
== 等于 双目操作符
!= 不等于 双目操作符
^ 位‘异或’ 双目操作符
+= 和赋值 双目操作符
-= 差赋值 双目操作符
*= 乘赋值 双目操作符
/= 商赋值 双目操作符
<<= 左移赋值 双目操作符
>>= 右移赋值 双目操作符
&= 按位‘与’赋值 双目操作符
^= 按位异或赋值 双目操作符
|= 按位或赋值 双目操作符
%= 模赋值 双目操作符
= 赋值 双目操作符
?: 按条件取值 双目操作符
, 间隔符 标点符号
# 预处理符号 标点符号
## 预处理符号 标点符号
sizeof 求字节数
~ 按位求反
| 位‘或’
： 间隔符
； 间隔符
... 间隔符
要把表中的运算符仔细的分类是不容易的，因为同一个运算符，在不同的地方其含义是不同的。如＊运算符，当作为乘运算时是双目操作符（所谓双目操作符，即运算时需要二个操作数），如3＊6，那么3与6总共是二个操作数。当作为取值运算时就是单目操作符（所谓单目操作符是只需要一个操作数）如对一个数求反：!a，这里只有一个操作数a。
要记住运算符的二个特点，一个是运算符的操作对象，另一个就是运算符的优先级别。其中运算符的优先级别是最不容易搞清楚和最容易出错的地方。
在讲运算符之前讲一下“表达式”的概念：所谓表达式，就是用运算符把各个操作数连接成符合C语法规则的进行运算的式子。这里说的“符合C语法的规则”也很重要。如 a+b+5就是一个用算术运算符连接起来的表达式。
1、算术运算符：＋、－、＊、/、%
1）＋、－、＊、/ 分别是相加、相减、相乘、相除
2）% 求二个数运算的模。所谓求模就是求二个数相除后的余数。例：25/3的余数是1，可以说25%3的模是1。要注意的是求模运算时二个操作数必须是整数。如果求25.3/3.1这样是不能运算的。
下面写一个例子：
#include<stdio.h> /*程序中要用到输入输出库函数，所以包含了stdio.h*/
void main()
{
int a=10,b=20,c=30; /*定义了3个整型变量，并同时进行了初始化赋值*/
a=a*b+c; /*a*b+c组成了一个算术表达式，运算后的结果为230并把值*/
/*赋给变量a*/
printf("%d",a); /*以整型格式输出变量a的值。这里输出230*/
a=a%b; /*进行求模运算。因为没有余数，最后的模为0*/
printf("%d",a); /*输出变量a的值。这里输出0*/
}
下面是一个要考虑运算符优先级的例子：
#include<stdio.h>
void main()
{
int a=10,b=20,c=30;
a=c-a*b; /*这里就要考虑运算符优先级，＊运算符的优先级比－运算符*/
/*的高，所以先进行乘运算。这里最后结果为-170*/
}
由上面这个例子看到，在一个有多个运算符连接起来的表达式中需要考虑运算符的优先级，这个例子很简单。关于运算符优先级的概念其实在小学生的算术运算中就有这样的概念了，只不过这里的运算符多了一些，要考虑的情况也就复杂了。
如果这个式子改写一下，写成：a=(c-a)*b;在运算时就以括号中的运算优先。
几个简化的运算表达式：
在C语言的程序中，经常看到这样的运算,如：i++;或者k--;这是运算符号的简化写法。
1、加1运算的简写
当一个变量进行加1运算时，如a=a+1;这是变量自身加1，简写为a++;
2、减1运算的简写
当一个变量进行减1运算时，如a=a-1;这是变量自身减1，简写为a--;
3、加1个常量运算的简写
当一个变量与一个常量相加时，如a=a+5;这是变量自身加5，简写为a+=5;
4、减一个常量运算的简写
当一个变量与一个常量相减时，如a=a-5;这是变量自身减5，简写为a-=5;
5、乘一个常量运算的简写
当一个变量与一个常量相乘时，如a=a*5，这是变量自身乘5，简写为a*=5;
6、除一个常量运算的简写
当一个变量与一个常量相除时，如a=a/5;这是变量自身除5，简写为a/=5;
运算符的结合性（或称作关联性）
在一个复杂的表达式中，常常有许多运算符和变量，这时就要判断优先级和结合性这二个因素。
例：-5+7; 这样的一个表达式用结合性来判断，因为运算符'-'和'+'相对于运算的数来说是‘左’结合的，所以就有'-5'和'+7'所以运算的结果为 2。
通过这个例子要知道什么是“左结合性”和“右结合性”
左结合性－－变量（或常量）与左边的运算符结合
右结合性－－变量（或常量）与右边的运算符结合
运算符的优先级和结合性表
优先级 运算符（高 －－－－－－→低） 结合率 运算符类型
高 ( ) [ ] -> . 从左至右 双目运算符
! ~ ++ -- （类型） sizeof + - * & 从右至左 单目运算符
* / % 从左至右 双目运算符
+ - 从左至右 双目运算符
<< >> 从左至右 双目运算符
< <= > >= 从左至右 双目运算符
== != 从左至右 双目运算符
& 从左至右 双目运算符
^ 从左至右 双目运算符
| 从左至右 双目运算符
&& 从左至右 双目运算符
|| 从左至右 双目运算符
?: 从右至左 三目运算符
低 = += -= *= /= %= &= ^= |= <<= >>= 从左至右 双目运算符
高 －－－－－－－－－－－－－→ 低
从表中可以看出一个规律，凡是单目运算符都是“右结合”的，凡是双目运算符都是“左结合”的。其中有一个?:运算符是三目运算符是右结合的，记住了这个规律，运算符的结合性也就掌握了。
如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免使用默认的优先级。
由于将表熟记是比较困难的，为了防止产生歧义并提高可读性，应当用括号确定表达式的操作顺序。例如：
d = (high << 8) | low /*用括号把需要先运算的括起来*/
if ((a | b) && (a & c)) /*用括号把需要先运算的括起来*/
例：
下列程序输出的结果是
#include<stdio.h>
void main()
{
int a=2;
a%=4-1;
printf("%d",a);
a+=a*=a-=a*=3;
printf("\n%d",a);
}
A. 2,0 B. 1,0
C. -1,12 D. 2,12
分析：由于%＝运算符的优先级别低于－运算，a%=4-1即是a%=3，等价于a=a%3即a=2%3=2，所以选项B和C是错误的。表达式a+=a*=a-=a*=3，计算时注意赋值类表达式的值和变量的值随时被更新，计算表达式的值，开始时a=2，表达式赋值是从左至右进行的，表达a*=3使得a=6，此表达式的值也为6，于是表达式a-=a*=3相当于a-=6=6-6=0，a的值为0，后面的计算就不用做了，所以a的值最终为0。
答：A
下列语句中错误的是
A.x=sizeof int;
B.x=sizeof 3.14
C.printf("%d",a=a+1,b--,c+1);
D.printf("%d",++x,x++);
分析：此题的选项A的作用是测试int类型所占内存的字节数，因为类型符要用括号括起来，这时缺少括号是错误的。
选项B是正确的。
选项C从表面上看似乎复杂一些，但其中的a=a+1,b--,c+1是一个逗号表达式，C语言允许使用这种表达式所以D也是正确的。
答案：A
下面的语句中，符合C语言语法的赋值语句是
A.a=7+b+c=a+7; B.a=7+b++=a+7;
C.a=7+b,b++,a+7; D.a=7+b;c=a+7;
分析：一般情况下，表达式不能放在赋值号的左边，所