07第四讲c语言基础知识_C语言知识总结

㈠ c语言基础

设计》课程，大多学生觉的这门课程难学。其实，按照我们现在的教学大纲和教学要求，只要同学们掌握一些方法，克服心理上畏难、不轻言放弃，是完全可以学好的。
《C程序设计》的内容很丰富，按照我们现在的教学大纲，教学的主要内容是基础知识、四种结构的的程序设计、函数与数组的应用和一些简单的算法。在学习时，同学们应该把主要精力放在这些部分，通过实践（练习和上机调试等熟练掌握。当然，在初学C语言时，可能会遇到有些问题理解不透，或者表达方式与以往数学学习中不同（如运算符等），这就要求不气馁，不明白的地方多问多想，鼓足勇气进行学习，待学完后面的章节知识，前面的问题也就迎刃而解了，这一方面我感觉是我们同学最欠缺，大多学不好的就是因为一开始遇到困难就放弃，曾经和好多同学谈他的问题，回答是听不懂、不想听、放弃这样三个过程，我反问，这节课你听过课吗？回答又是没有，根本就没听过课，怎么说自己听不懂呢？相应的根本就没学习，又谈何学的好？
学习C语言始终要记住“曙光在前头”和“千金难买回头看”，“千金难买回头看”是学习知识的重要方法，就是说，学习后面的知识，不要忘了回头弄清遗留下的问题和加深理解前面的知识，这是我们学生最不易做到的，然而却又是最重要的。比如：在C语言中最典型的是关于结构化程序设计构思，不管是那种教材，一开始就强调这种方法，这时也许你不能充分体会，但是学到函数时，再回头来仔细体会，温故知新，理解它就没有那么难了。学习C语言就是要经过几个反复，才能前后贯穿，积累应该掌握的C知识。
那么，我们如何学好《C程序设计》呢？
一．学好C语言的运算符和运算顺序
这是学好《C程序设计》的基础，C语言的运算非常灵活，功能十分丰富，运算种类远多于其它程序设计语言。在表达式方面较其它程序语言更为简洁，如自加、自减、逗号运算和三目运算使表达式更为简单，但初学者往往会觉的这种表达式难读，关键原因就是对运算符和运算顺序理解不透不全。当多种不同运算组成一个运算表达式，即一个运算式中出现多种运算符时，运算的优先顺序和结合规则显得十分重要。在学习中，只要我们对此合理进行分类，找出它们与我们在数学中所学到运算之间的不同点之后，记住这些运算也就不困难了，有些运算符在理解后更会牢记心中，将来用起来得心应手，而有些可暂时放弃不记，等用到时再记不迟。
先要明确运算符按优先级不同分类，《C程序设计》运算符可分为15种优先级，从高到低，优先级为1 ~ 15，除第2、3级和第14级为从右至左结合外，其它都是从左至右结合，它决定同级运算符的运算顺序。下面我们通过几个例子来说明：
（1） 5*8/4%10 这个表达式中出现3种运算符，是同级运算符，运算顺序按从左至右结合，因此先计算5 *8=40，然后被4除，结果为10，最后是%（求余数）运算，所以表达式的最终结果为10%10 = 0；
（2）a = 3;b = 5;c =++ a* b ；d =a + +* b；
对于c=++a*b来说，按表中所列顺序，+ +先执行，*后执行，所以+ + a执行后，a的值为4，由于+ +为前置运算，所以a的值4参与运算，C的值计算式为4*5=20而不是3*5=15了；而对于d=a++*b来说，由于a + +为后置运算，所以a值为4参与运算，使得d的值仍为20，而a参与运算后其值加1，值为5。这个例子执行后，a的值为5，b的值为5，c的值为20，d的值也是20；
（3）（a = 3，b = 5，b+ = a，c = b* 5）
例子中的“，”是逗号结合运算，上式称为逗号表达式，自左向右结合，最后一个表达式的结果值就是逗号表达式的结果，所以上面的逗号表达式结果为40，a的值为3，b的值为8，c的值为40。
（4）a=5;b=6;c=a>b?a:b;
例中的a>b?a:b是一个三目运算，它的功能是先做关系运算a>b部分，若结果为真，则取问号后a的值，否则取冒号后b的值，因此c的值应该为6，这个运算可以用来代替if…else…语句的简单应用。
二．学好C语言的四种程序结构
（1）顺序结构
顺序结构的程序设计是最简单的，只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。
例如；a = 3，b = 5，现交换a，b的值，这个问题就好象交换两个杯子水，这当然要用到第三个杯子，假如第三个杯子是c，那么正确的程序为： c = a； a = b； b = c；执行结果是a = 5，b = c = 3如果改变其顺序，写成：a = b； c = a； b = c；则执行结果就变成a = b = c = 5，不能达到预期的目的，初学者最容易犯这种错误。顺序结构可以独立使用构成一个简单的完整程序，常见的输入、计算，输出三步曲的程序就是顺序结构，例如计算圆的面积，其程序的语句顺序就是输入圆的半径r，计算s = 3.14159*r*r,输出圆的面积s。不过大多数情况下顺序结构都是作为程序的一部分，与其它结构一起构成一个复杂的程序，例如分支结构中的复合语句、循环结构中的循环体等。
（2）分支结构
顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。分支结构的执行是依据一定的条件选择执行路径，而不是严格按照语句出现的物理顺序。分支结构的程序设计方法的关键在于构造合适的分支条件和分析程序流程，根据不同的程序流程选择适当的分支语句。分支结构适合于带有逻辑或关系比较等条件判断的计算，设计这类程序时往往都要先绘制其程序流程图，然后根据程序流程写出源程序，这样做把程序设计分析与语言分开，使得问题简单化，易于理解。程序流程图是根据解题分析所绘制的程序执行流程图。
学习分支结构不要被分支嵌套所迷惑，只要正确绘制出流程图，弄清各分支所要执行的功能，嵌套结构也就不难了。嵌套只不过是分支中又包括分支语句而已，不是新知识，只要对双分支的理解清楚，分支嵌套是不难的。下面我介绍几种基本的分支结构。
①if(条件)
{
分支体
}
这种分支结构中的分支体可以是一条语句，此时“”可以省略，也可以是多条语句即复合语句。它有两条分支路径可选，一是当条件为真，执行分支体，否则跳过分支体，这时分支体就不会执行。如：要计算x的绝对值，根据绝对值定义，我们知道，当x>=0时，其绝对值不变，而x<0时其绝对值是为x的反号，因此程序段为：if(x<0) x=-x;
②if(条件)

else

这是典型的分支结构，如果条件成立，执行分支1，否则执行分支2，分支1和分支2都可以是1条或若干条语句构成。如：求ax^2+bx+c=0的根
分析：因为当b^2-4ac>=0时,方程有两个实根，否则（b^2-4ac<0）有两个共轭复根。其程序段如下：

d=b*b-4*a*c;
if(d>=0)
{x1=(-b+sqrt(d))/2a;
x1=(-b-sqrt(d))/2a;
printf(“x1=%8.4f,x2=%8.4f\n”,x1,x2);
}
else
{r=-b/(2*a);
i =sqrt(-d)/(2*a);
printf(“x1=%8.4f+%8.4fi\n”r, i);
printf(“x2=%8.4f-%8.4fi\n”r,i)
}
③嵌套分支语句：其语句格式为：
if(条件1) ；
else if（条件2）
else if（条件3）
……
else if（条件n）
else
嵌套分支语句虽可解决多个入口和出口的问题，但超过3重嵌套后，语句结构变得非常复杂，对于程序的阅读和理解都极为不便，建议嵌套在3重以内，超过3重可以用下面的语句。
④switch开关语句：该语句也是多分支选择语句，到底执行哪一块，取决于开关设置，也就是表达式的值与常量表达式相匹配的那一路，它不同if…else 语句，它的所有分支都是并列的，程序执行时，由第一分支开始查找，如果相匹配，执行其后的块，接着执行第2分支，第3分支……的块，直到遇到break语句；如果不匹配，查找下一个分支是否匹配。这个语句在应用时要特别注意开关条件的合理设置以及break语句的合理应用。
（3）循环结构：
循环结构可以减少源程序重复书写的工作量，用来描述重复执行某段算法的问题，这是程序设计中最能发挥计算机特长的程序结构，C语言中提供四种循环，即goto循环、while循环、do –while循环和for循环。四种循环可以用来处理同一问题，一般情况下它们可以互相代替换，但一般不提倡用goto循环，因为强制改变程序的顺序经常会给程序的运行带来不可预料的错误，在学习中我们主要学习while、do…while、for三种循环。常用的三种循环结构学习的重点在于弄清它们相同与不同之处，以便在不同场合下使用，这就要清楚三种循环的格式和执行顺序，将每种循环的流程图理解透彻后就会明白如何替换使用，如把while循环的例题，用for语句重新编写一个程序，这样能更好地理解它们的作用。特别要注意在循环体内应包含趋于结束的语句（即循环变量值的改变），否则就可能成了一个死循环，这是初学者的一个常见错误。
在学完这三个循环后，应明确它们的异同点：用while和do…while循环时，循环变量的初始化的操作应在循环体之前，而for循环一般在语句1中进行的；while 循环和for循环都是先判断表达式，后执行循环体，而do…while循环是先执行循环体后判断表达式，也就是说do…while的循环体最少被执行一次，而while 循环和for就可能一次都不执行。另外还要注意的是这三种循环都可以用break语句跳出循环，用continue语句结束本次循环，而goto语句与if构成的循环，是不能用break和 continue语句进行控制的。
顺序结构、分支结构和循环结构并不彼此孤立的，在循环中可以有分支、顺序结构，分支中也可以有循环、顺序结构，其实不管哪种结构，我们均可广义的把它们看成一个语句。在实际编程过程中常将这三种结构相互结合以实现各种算法，设计出相应程序，但是要编程的问题较大，编写出的程序就往往很长、结构重复多，造成可读性差，难以理解，解决这个问题的方法是将C程序设计成模块化结构。
(4)模块化程序结构
C语言的模块化程序结构用函数来实现，即将复杂的C程序分为若干模块，每个模块都编写成一个C函数，然后通过主函数调用函数及函数调用函数来实现一大型问题的C程序编写，因此常说：C程序=主函数+子函数。因些，对函数的定义、调用、值的返回等中要尤其注重理解和应用，并通过上机调试加以巩固。
三．掌握一些简单的算法
编程其实一大部分工作就是分析问题，找到解决问题的方法，再以相应的编程语言写出代码。这就要求掌握算法，根据我们的《C程序设计》教学大纲中，只要求我们掌握一些简单的算法，在掌握这些基本算法后，要完成对问题的分析就容易了。如两个数的交换、三个数的比较、选择法排序和冒泡法排序，这就要求我们要清楚这些算法的内在含义，其中选择法排序和冒泡法排序稍难，但只要明白排序的具体过程，对代码的理解就不难了。如用选择法对10个不同整数排序（从小到大），选择法排序思路：设有10个元素a[1]~a[10],将a[1]与a[2]~a[10]比较，若a[1]比a[2]~a[10]都小，则不进行交换，即无任何操作；若a[2]~a[10] 中有一个比a[1]小，则将其中最大的一个（假设为a[i]）与a[1]交换，此时a[1]中存放了10个中最小的数。第二轮将a[2]与a[3]~a[10]比较，将剩下9个数中的最小者a[i]与a[2]交换，此时a[2] 中存放的10个数中第2小的数；依此类推，共进行9轮比较，a[1]到a[10]就已按从小到大的顺序存放。即每一轮都找出剩下数中的最小一个，代码如下：
for(i=1;i<=9;i++)
for(j=i+1;j<=10;j++)
if(a[i]>a[j]
{temp=a[i];
a[i]=a[j];
a[j]=temp;
}
结语：当我们把握好上述几方面后，只要同学们能克服畏难、厌学、上课能专心听讲，做好练习与上机调试，其实C语言并不难学。
l8

㈡谁能给我一些C语言入门知识.详细点..

1、 DIP40双列直插；
2、 P0，P1，P2，P3四个8位准双向I/O引脚；（作为I/O输入时，要先输出高电平）
3、电源VCC（PIN40）和地线GND（PIN20）；
4、高电平复位RESET（PIN9）；（10uF电容接VCC与RESET，即可实现上电复位）
5、内置振荡电路，外部只要接晶体至X1（PIN18）和X0（PIN19）；（频率为主频的12倍）
6、程序配置EA（PIN31）接高电平VCC；（运行单片机内部ROM中的程序）
7、 P3支持第二功能：RXD、TXD、INT0、INT1、T0、T1

单片机内部I/O部件：(所胃学习单片机，实际上就是编程控制以下I/O部件，完成指定任务)
1、四个8位通用I/O端口，对应引脚P0、P1、P2和P3；
2、两个16位定时计数器；（TMOD，TCON，TL0，TH0，TL1，TH1）
3、一个串行通信接口；（SCON，SBUF）
4、一个中断控制器；（IE，IP）

针对AT89S52单片机，头文件AT89x52.h给出了SFR特殊功能寄存器所有端口的定义。

C语言编程基础正式内容：

1、十六进制表示字节0x5a：二进制为01011010B；0x6E为01101110。
2、如果将一个16位二进数赋给一个8位的字节变量，则自动截断为低8位，而丢掉高8位。
3、 ++var表示对变量var先增一；var—表示对变量后减一。
4、 x |= 0x0f;表示为 x = x | 0x0f;
5、 TMOD = ( TMOD & 0xf0 ) | 0x05;表示给变量TMOD的低四位赋值0x5，而不改变TMOD的高四位。
6、 While( 1 ); 表示无限执行该语句，即死循环。语句后的分号表示空循环体，也就是{;}

在某引脚输出高电平的编程方法：（比如P1.3（PIN4）引脚）
#include <AT89x52.h> //该头文档中有单片机内部资源的符号化定义，其中包含P1.3
void main( void ) //void 表示没有输入参数，也没有函数返值，这入单片机运行的复位入口
{
P1_3 = 1; //给P1_3赋值1，引脚P1.3就能输出高电平VCC
While( 1 ); //死循环，相当 LOOP: goto LOOP;
}
注意：P0的每个引脚要输出高电平时，必须外接上拉电阻（如4K7）至VCC电源。

在某引脚输出低电平的编程方法：（比如P2.7引脚）
#include <AT89x52.h> //该头文档中有单片机内部资源的符号化定义，其中包含P2.7
void main( void ) //void 表示没有输入参数，也没有函数返值，这入单片机运行的复位入口
{
P2_7 = 0; //给P2_7赋值0，引脚P2.7就能输出低电平GND
While( 1 ); //死循环，相当 LOOP: goto LOOP;
}

在某引脚输出方波编程方法：（比如P3.1引脚）
#include <AT89x52.h> //该头文档中有单片机内部资源的符号化定义，其中包含P3.1
void main( void ) //void 表示没有输入参数，也没有函数返值，这入单片机运行的复位入口
{
While( 1 ) //非零表示真，如果为真则执行下面循环体的语句
{
P3_1 = 1; //给P3_1赋值1，引脚P3.1就能输出高电平VCC
P3_1 = 0; //给P3_1赋值0，引脚P3.1就能输出低电平GND
} //由于一直为真，所以不断输出高、低、高、低……，从而形成方波
}

将某引脚的输入电平取反后，从另一个引脚输出：（比如 P0.4 = NOT( P1.1) ）
#include <AT89x52.h> //该头文档中有单片机内部资源的符号化定义，其中包含P0.4和P1.1
void main( void ) //void 表示没有输入参数，也没有函数返值，这入单片机运行的复位入口
{
P1_1 = 1; //初始化。P1.1作为输入，必须输出高电平
While( 1 ) //非零表示真，如果为真则执行下面循环体的语句
{
if( P1_1 == 1 ) //读取P1.1，就是认为P1.1为输入，如果P1.1输入高电平VCC
{ P0_4 = 0; } //给P0_4赋值0，引脚P0.4就能输出低电平GND
else //否则P1.1输入为低电平GND
{ P0_4 = 1; } //给P0_4赋值1，引脚P0.4就能输出高电平VCC
} //由于一直为真，所以不断根据P1.1的输入情况，改变P0.4的输出电平
}

将某端口8个引脚输入电平，低四位取反后，从另一个端口8个引脚输出：（比如 P2 = NOT( P3 ) ）
#include <AT89x52.h> //该头文档中有单片机内部资源的符号化定义，其中包含P2和P3
void main( void ) //void 表示没有输入参数，也没有函数返值，这入单片机运行的复位入口
{
P3 = 0xff; //初始化。P3作为输入，必须输出高电平，同时给P3口的8个引脚输出高电平
While( 1 ) //非零表示真，如果为真则执行下面循环体的语句
{ //取反的方法是异或1，而不取反的方法则是异或0
P2 = P3^0x0f //读取P3，就是认为P3为输入，低四位异或者1，即取反，然后输出
} //由于一直为真，所以不断将P3取反输出到P2
}
注意：一个字节的8位D7、D6至D0，分别输出到P3.7、P3.6至P3.0，比如P3=0x0f，则P3.7、P3.6、P3.5、P3.4四个引脚都输出低电平，而P3.3、P3.2、P3.1、P3.0四个引脚都输出高电平。同样，输入一个端口P2，即是将P2.7、P2.6至P2.0，读入到一个字节的8位D7、D6至D0。

第一节：单数码管按键显示

1、接电源：VCC（PIN40）、GND（PIN20）。加接退耦电容0.1uF
2、接晶体：X1（PIN18）、X2（PIN19）。注意标出晶体频率（选用12MHz），还有辅助电容30pF
3、接复位：RES（PIN9）。接上电复位电路，以及手动复位电路，分析复位工作原理
4、接配置：EA（PIN31）。说明原因。

发光二极的控控制：单片机I/O输出
将一发光二极管LED的正极（阳极）接P1.1，LED的负极（阴极）接地GND。只要P1.1输出高电平VCC，LED就正向导通（导通时LED上的压降大于1V），有电流流过LED，至发LED发亮。实际上由于P1.1高电平输出电阻为10K，起到输出限流的作用，所以流过LED的电流小于（5V-1V）/10K = 0.4mA。只要P1.1输出低电平GND，实际小于0.3V，LED就不能导通，结果LED不亮。（注意和本电路相反）

开关双键的输入：输入先输出高
一个按键KEY_ON接在P1.6与GND之间，另一个按键KEY_OFF接P1.7与GND之间，按KEY_ON后LED亮，按KEY_OFF后LED灭。同时按下LED半亮，LED保持后松开键的状态，即ON亮OFF灭。
#include <at89x52.h>
#define LED P1^1 //用符号LED代替P1_1
#define KEY_ON P1^6 //用符号KEY_ON代替P1_6
#define KEY_OFF P1^7 //用符号KEY_OFF代替P1_7
void main( void ) //单片机复位后的执行入口，void表示空，无输入参数，无返回值
{
KEY_ON = 1; //作为输入，首先输出高，接下KEY_ON，P1.6则接地为0，否则输入为1
KEY_OFF = 1; //作为输入，首先输出高，接下KEY_OFF，P1.7则接地为0，否则输入为1
While( 1 ) //永远为真，所以永远循环执行如下括号内所有语句
{
if( KEY_ON==0 ) LED=1; //是KEY_ON接下，所示P1.1输出高，LED亮
if( KEY_OFF==0 ) LED=0; //是KEY_OFF接下，所示P1.1输出低，LED灭
} //松开键后，都不给LED赋值，所以LED保持最后按键状态。
//同时按下时，LED不断亮灭，各占一半时间，交替频率很快，由于人眼惯性，看上去为半亮态
}

数码管的接法和驱动原理
一支七段数码管实际由8个发光二极管构成，其中7个组形构成数字8的七段笔画，所以称为七段数码管，而余下的1个发光二极管作为小数点。作为习惯，分别给8个发光二极管标上记号：a,b,c,d,e,f,g,h。对应8的顶上一画，按顺时针方向排，中间一画为g，小数点为h。
我们通常又将各二极与一个字节的8位对应，a(D0),b(D1),c(D2),d(D3),e(D4),f(D5),g(D6),h(D7)，相应8个发光二极管正好与单片机一个端口Pn的8个引脚连接，这样单片机就可以通过引脚输出高低电平控制8个发光二极的亮与灭，从而显示各种数字和符号；对应字节，引脚接法为：a(Pn.0)，b(Pn.1)，c(Pn.2)，d(Pn.3)，e(Pn.4)，f(Pn.5)，g(Pn.6)，h(Pn.7)。
如果将8个发光二极管的负极（阴极）内接在一起，作为数码管的一个引脚，这种数码管则被称为共阴数码管，共同的引脚则称为共阴极，8个正极则为段极。否则，如果是将正极（阳极）内接在一起引出的，则称为共阳数码管，共同的引脚则称为共阳极，8个负极则为段极。
以单支共阴数码管为例，可将段极接到某端口Pn，共阴极接GND，则可编写出对应十六进制码的七段码表字节数据如右图：

16键码显示的程序
我们在P1端口接一支共阴数码管SLED，在P2、P3端口接16个按键，分别编号为KEY_0、KEY_1到KEY_F，操作时只能按一个键，按键后SLED显示对应键编号。
#include <at89x52.h>
#define SLED P1
#define KEY_0 P2^0
#define KEY_1 P2^1
#define KEY_2 P2^2
#define KEY_3 P2^3
#define KEY_4 P2^4
#define KEY_5 P2^5
#define KEY_6 P2^6
#define KEY_7 P2^7
#define KEY_8 P3^0
#define KEY_9 P3^1
#define KEY_A P3^2
#define KEY_B P3^3
#define KEY_C P3^4
#define KEY_D P3^5
#define KEY_E P3^6
#define KEY_F P3^7
Code unsigned char Seg7Code[16]= //用十六进数作为数组下标，可直接取得对应的七段编码字节
// 0 1 2 3 4 5 6 7 8 9 A b C d E F
{0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71};
void main( void )
{
unsigned char i=0; //作为数组下标
P2 = 0xff; //P2作为输入，初始化输出高
P3 = 0xff; //P3作为输入，初始化输出高
While( 1 )
{
if( KEY_0 == 0 ) i=0; if( KEY_1 == 0 ) i=1;
if( KEY_2 == 0 ) i=2; if( KEY_3 == 0 ) i=3;
if( KEY_4 == 0 ) i=4; if( KEY_5 == 0 ) i=5;
if( KEY_6 == 0 ) i=6; if( KEY_7 == 0 ) i=7;
if( KEY_8 == 0 ) i=8; if( KEY_9 == 0 ) i=9;
if( KEY_A == 0 ) i=0xA; if( KEY_B == 0 ) i=0xB;
if( KEY_C == 0 ) i=0xC; if( KEY_D == 0 ) i=0xD;
if( KEY_E == 0 ) i=0xE; if( KEY_F == 0 ) i=0xF;
SLED = Seg7Code[ i ]; //开始时显示0，根据i取应七段编码
}
}

第二节：双数码管可调秒表

解：只要满足题目要求，方法越简单越好。由于单片机I/O资源足够，所以双数码管可接成静态显示方式，两个共阴数码管分别接在P1（秒十位）和P2（秒个位）口，它们的共阴极都接地，安排两个按键接在P3.2（十位数调整）和P3.3（个位数调整）上，为了方便计时，选用12MHz的晶体。为了达到精确计时，选用定时器方式2，每计数250重载一次，即250us，定义一整数变量计数重载次数，这样计数4000次即为一秒。定义两个字节变量S10和S1分别计算秒十位和秒个位。编得如下程序：
#include <at89x52.h>
Code unsigned char Seg7Code[16]= //用十六进数作为数组下标，可直接取得对应的七段编码字节
// 0 1 2 3 4 5 6 7 8 9 A b C d E F
{0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71};
void main( void )
{
unsigned int us250 = 0;
unsigned char s10 = 0;
unsigned char s1 = 0;
unsigned char key10 = 0; //记忆按键状态，为1按下
unsigned char key1 = 0; //记忆按键状态，为1按下
//初始化定时器 Timer0
TMOD = (TMOD & 0xF0) | 0x02;
TH1 = -250; //对于8位二进数来说，-250=6，也就是加250次1时为256，即为0
TR1 = 1;
while(1){ //----------循环1
P1 = Seg7Code[ s10 ]; //显示秒十位
P2 = Seg7Code[ s1 ]; //显示秒个位
while( 1 ){ //----------循环2
//计时处理
if( TF0 == 1 ){
TF0 = 0;
if( ++us250 >= 4000 ){
us250 = 0;
if( ++s1 >= 10 ){
s1 = 0;
if( ++s10 >= 6 ) s10 = 0;
}
break; //结束“循环2”，修改显示
}
}
//按十位键处理
P3.2 = 1; //P3.2作为输入，先要输出高电平
if( key10 == 1 ){ //等松键
if( P3.2 == 1 ) key10=0;
}
else{ //未按键
if( P3.2 == 0 ){
key10 = 1;
if( ++s10 >= 6 ) s10 = 0;
break; //结束“循环2”，修改显示
}
}
//按个位键处理
P3.3 = 1; //P3.3作为输入，先要输出高电平
if( key1 == 1 ) //等松键
{ if( P3.3 == 1 ) key1=0; }
else { //未按键
if( P3.3 == 0 ){ key1 = 1;
if( ++s1 >= 10 ) s1 = 0;
break; //结束“循环2”，修改显示
}
}
} //循环2’end
}//循环1’end
}//main’end

第三节：十字路口交通灯

如果一个单位时间为1秒，这里设定的十字路口交通灯按如下方式四个步骤循环工作：
l 60个单位时间，南北红，东西绿；
l 10个单位时间，南北红，东西黄；
l 60个单位时间，南北绿，东西红；
l 10个单位时间，南北黄，东西红；
解：用P1端口的6个引脚控制交通灯，高电平灯亮，低电平灯灭。
#include <at89x52.h>
//sbit用来定义一个符号位地址，方便编程，提高可读性，和可移植性
sbit SNRed =P1^0; //南北方向红灯
sbit SNYellow =P1^1; //南北方向黄灯
sbit SNGreen =P1^2; //南北方向绿灯
sbit EWRed =P1^3; //东西方向红灯
sbit EWYellow =P1^4; //东西方向黄灯
sbit EWGreen =P1^5; //东西方向绿灯
/* 用软件产生延时一个单位时间 */
void Delay1Unit( void )
{
unsigned int i, j;
for( i=0; i<1000; i++ )
for( j<0; j<1000; j++ ); //通过实测，调整j循环次数,产生1ms延时
//还可以通过生成汇编程序来计算指令周期数，结合晶体频率来调整j循环次数，接近1ms
}
/* 延时n个单位时间 */
void Delay( unsigned int n ){ for( ; n!=0; n-- ) Delay1Unit(); }
void main( void )
{
while( 1 )
{
SNRed=0; SNYellow=0; SNGreen=1; EWRed=1; EWYellow=0; EWGreen=0; Delay( 60 );
SNRed=0; SNYellow=1; SNGreen=0; EWRed=1; EWYellow=0; EWGreen=0; Delay( 10 );
SNRed=1; SNYellow=0; SNGreen=0; EWRed=0; EWYellow=0; EWGreen=1; Delay( 60 );
SNRed=1; SNYellow=0; SNGreen=0; EWRed=0; EWYellow=1; EWGreen=0; Delay( 10 );
}
}

㈢ c语言有哪些基础知识

C语言是一门面向过程的、抽象化的通用程序设计语言，广泛应用于底层开发。

C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。

尽管C语言提供了许多低级处理的功能，但仍然保持着跨平台的特性，以一个标准规格写出的C语言程序可在包括类似嵌入式处理器以及超级计算机等作业平台的许多计算机平台上进行编译。

(3)07第四讲c语言基础知识扩展阅读：

C语言的字符串其实就是以''字符结尾的char型数组，使用字符型并不需要引用库，但是使用字符串就需要C标准库里面的一些用于对字符串进行操作的函数。

它们不同于字符数组。使用这些函数需要引用头文件<string.h>。

在C语言中，输入和输出是经由标准库中的一组函数来实现的。在ANSI C中，这些函数被定义在头文件<stdio.h>；中。

㈣ c语言入门教学

楼主，你可以去编程入门网，那里有挺多知识点的，很多语言都有，很适合初学者，你也可以去CSDN，那里有很多源代码提供下载，也有论坛，呵呵，你也不要忽视网络贴吧，知道，贴吧是学习很多课本没有东西的地方，知道，你需要看解决答案，这样很有收获，你也可以去中国编程网，不过，我觉得一楼也是有道理的，看看书掌握知识点，网上我觉得主要还是提高的地方哦……呵呵……关于怎么学，我是这么过来的，每看一节书，做一节课后习题，其实初学主要还是学习语法和算法（解决问题的方法），多上机自己写程序，写不出来看答案的算法，自己再写一边，关键这个阶段还是积累为主，基本知识学好了，可以学深入编程，不过你需要有熟悉的语法，可以写一些小程序：学生成绩管理系统等等，就过关了，然后可以学习链表，图像编程，等等高级编程……呵呵……努力一定有回报的……加油吧…

㈤ C语言的基本知识。

C语言的基本知识；if-else 结构的应用：
编写计算器程序，要求从键盘任意输入两个数值，然后输入一个四则运算符，自动完成后输出结果 2 switch 结构的应用：
从键盘输入一个百分制成绩，要求输出成绩等级'A''B'C''D''E'。90分以上为'A',80-89为'B',70-79为'C',60-69为'D',60分以下为'E'.
#include<stdio.h>
void main()
{float score; char grade; 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'; }
printf("成绩是%5.1f,相应等级是%c。\n",score,grade);
}
3 do-while循环的应用:
利用下述公式求PI的近似值,要求满足计算精度为0.0001
PI/4≈1-1/3+1/5-1/7+1/9-...
#include<stdio.h>
#include<math.h>
void main()
{int s; float n,t,pi; t=1;pi=0;n=1.0;s=1; do { pi=pi+t; n+=2; s=-s; t=s/n; }
while(fabs(1/n)>1e-4);
printf("pi=%10.6f",4*pi);
}
4 for循环的应用:
(1)求素数的累加和.从键盘任意输入20个整数,将所有素数累加后输出.
#include<stdio.h>
#include<math.h>
prime(int x[],int n)
{int i,j,k,s=0; for(i=0;i<n;i++) {k=sqrt(x[i]); for(j=2;j<=k;j++) if(x[i]%j==0) break; if(j>k) s+=x[i]; }
return s;
}
main()
{int a[20],*p,s=0,i; p=a; for(i=0;i<20;i++) scanf("%d",p++); p=a; s=prime(p,20); printf("%d",s); }
(2)无重复数字的3位数问题.用1.2.3.4 组成无重复数字的3位数,将这些3位数据全部输出.
#include<stdio.h>
void main()
{
int i,j,k;
for(i=1;i<=2;i++)
{
for(j=i+1;j<=3;j++)
{
for(k=j+1;k<=4;k++)
{
printf("%d\n",100*i+10*j+k);
printf("%d\n",100*i+10*k+j);
printf("%d\n",100*j+10*i+k);
printf("%d\n",100*j+10*k+i);
printf("%d\n",100*k+10*i+j);
printf("%d\n",100*k+10*j+i);
}
}
}
}
5 字符型数组应用:
设计程序.输入一篇不超过80个字符的短文(包括空格),保存到一维字符数组中,求字母a出现的次数并输出.
#include<stdio.h>
#include<string.h>
void main()
{char s[80]; int i,n,times=0; gets(s); n=strlen(s); for(i=0;i<n;i++) if(s[i]=='a') times+=1; printf("\n The result is:%d\n",times); }
6 数值型数组应用:
设计程序将Fibonacci数列前20项中的奇数找出来存放到一维数组中.
#include<stdio.h>
void main()
{int i,s=0,j=0; int f[20]={1,1},a[20];
for(i=2;i<20;i++)
f[i]=f[i-2]+f[i-1];
for(i=0;i<20;i++)
{if(i%5==0) printf("\n"); printf("%12d",f[i]); }
printf("\n");
for(i=0;i<20;i++)
if(f[i]%2!=0)
{a[j]=f[i];j+=1;}
for(i=0;i<j;i++)
printf("%d ",a[i]);
}
7 函数调用(形参为变量的情况):
用函数调用的方式求 x!+y!+z!之值.
#include<stdio.h>
sum(int a)
{int n,t=1; for(n=1;n<=a;n++) t*=n; return t; }
main()
{int x,y,z,s=0; scanf("%d %d %d",&x,&y,&z); s=sum(x)+sum(y)+sum(z); printf("%d!+%d!+%d!=%d\n",x,y,z,s); 2008-6-19 20:22 回复 muniezuo 1位粉丝 2楼}
8 函数调用(形参为数组名的情况):
选择法排序函数的定义及使用.编写一个用选择法对一维数组升序排列的函数,并在主函数中调用该排序函数,实现对任意20个整数的排序.
#include<stdio.h>
sort(int x[],int n)
{int i,j,k,t; for(i=0;i<n-1;i++) {k=i; for(j=i+1;j<n;j++) if(x[j]<x[k]) k=j; if(k!=i) {t=x[i];x[i]=x[k];x[k]=t;}
}
}
main()
{int *p,i,a[20]; p=a; for(i=0;i<20;i++) scanf("%d",p++); p=a; sort(p,20); for(p=a,i=0;i<20;i++) {printf("%d ",*p);p++;}
}
9 指针
(1)程序填空
下面程序中,函数fun的功能是:将s所指字符串中下标为偶数的字符删除,s中剩余的字符形成的新串放在t所指的数组中.例如,当s所指字符串中的内容为"ABCDEFGHIJK",在t 所指数组中的内容应是"BDFHJ"
#include<conio.h>
#include<stdio.h>
#include<string.h>
void fun(char *s,char t[])
{int i,j,n; n=strlen(s); for(i=0,j=0;i<n;i++) if(i!=2*j) {t[j]=s[i];j++;}
t[j]='\0';
}
void main()
{char s[80],t[80]; printf("\n Please enter string s: "); scanf("%s",s); fun(s,t); printf("\n The result is:%s\n",t); }
(2)程序改错
下面程序中的sub函数的功能是:将s所指字符串的反序和正序进行连接形成一个新串放在t所指的数组中.
#include"stdio.h"
#include"conio.h"
#include"string.h"
void sub(char *s,char *t)
{int i,d; d=strlen(s); for(i=0;i<d;i++) t[i]=s[d-1-i]; for(i=0;i<d;i++) t[d+i]=s[i]; t[2*d]='\0'; }
main()
{char s[100],t[100]; printf("\n Please enter string s:"); scanf("%s",s); sub(s,t); printf("\n The result is : %s \n",t); }
10 结构体:有10个学生,4门课成绩,设计程序,计算每个学生的总分和平均分,
并打印学生的成绩排名表.
要求:定义结构体类型,成员有学号,姓名,4科成绩
#include<stdio.h>
#define N 10 struct student
{
long num;
int score[4];
int add;
double aver;
}stu[N]; void main()
{
int i,j,sum;
char c[4][10]={"math","English","computer","physics"};
void paixu(struct student stu[]);
printf("请输入学生的成绩:\n");
for(i=0;i<N;i++)
{sum=0; printf("输入第%d个学生的学号:",i+1); scanf("%ld",&stu[i].num); for(j=0;j<4;j++) {printf("输入%s成绩:",c[j]); scanf("%d",&stu[i].score[j]); sum+=stu[i].score[j];}
stu[i].add=sum;
stu[i].aver=stu[i].add/4.0;
}
for(i=0;i<N;i++)
a[i]=stu[i].add;
paixu(stu);
for(i=0;i<N;i++)
printf("%d\t%ld\t%d\t%d\t%d\t%d\t%d\t%6.2f\n",i+1,stu[i].num,stu[i].score[0],stu[i].score[1],stu[i].score[2],stu[i].score[3],stu[i].add,stu[i].aver);
}
void paixu(struct student stu[])
{
int i,j;
struct student t;
for(i=0;i<N-1;i++)
for(j=i+1;j<N;j++)
if(stu[j].add>stu[i].add)
{t=stu[j];stu[j]=stu[i];stu[i]=t;}
}
11 文件:建立一个数据文件,将10题中的成绩排名表写入数据文件中,完成后,关闭该数据文件;打开数据文件并将内容显示在屏幕上,以便验证
#include<stdio.h>
#define N 10 struct student
{
long num;
int score[4];
int add;
double aver;
}stu[N]; void save()
{FILE *fp; int i; if((fp=fopen("stu_list","wb"))==NULL) {printf("cannot open file\n"); return; }
for(i=0;i<N;i++)
if(fwrite(&stu[i],sizeof(struct student),1,fp)!=1)
printf("file write error\n");
fclose(fp);
} void main()
{FILE *fp; int i,j,sum; char c[4][10]={"math","English","computer","physics"};
void paixu(struct student stu[]);
printf("请输入学生的成绩:\n");
for(i=0;i<N;i++)
{sum=0; printf("输入第%d个学生的学号:",i+1); scanf("%ld",&stu[i].num); for(j=0;j<4;j++) {printf("输入%s成绩:",c[j]); scanf("%d",&stu[i].score[j]); sum+=stu[i].score[j];}
stu[i].add=sum;
stu[i].aver=stu[i].add/4.0;
}
paixu(stu);
save();
fp=fopen("stu_list","rb");
for(i=0;i<N;i++)
{fread(&stu[i],sizeof(struct student),1,fp); printf("%d\t%ld\t%d\t%d\t%d\t%d\t%d\t%6.2f\n",i+1,stu[i].num,stu[i].score[0],stu[i].score[1],stu[i].score[2],stu[i].score[3],stu[i].add,stu[i].aver); }
fclose(fp);
} void paixu(struct student stu[])
{
int i,j;
struct student t;
for(i=0;i<N-1;i++)
for(j=i+1;j<N;j++)
if(stu[j].add>stu[i].add)
{t=stu[j];stu[j]=stu[i];stu[i]=t;}
}

㈥关于学习c语言的问题

他说的没错这本说的确很好我也在学习这半书
我这里有点笔记是高手们学习c语言留下的我想也许对你会有用
C程序入门
第一讲语言的分类
一。低级语言：计算机语言,采用二进制进行编程，用户难度大，机器易识别。
二。汇编语言：（低级语言）采用简单的英文字母进行编程，用户稍意识别，计算机不能使被识别，需翻译。
汇编程序：将汇编语言译成机器语言。
反汇编语言：将机器语言译成汇编语言。
三。高级语言∶采用近于自然语言进行编程，用户易编程，计算机不能识别，需翻译，速度慢。
解释程序：整句翻译；
编译程序：整个程序翻译；
二，C语言的特点
1，C语言是一门中级语言
低级语言：直接访问硬件
高级语言：自然语言移植性较好
2，C是一门结构化程序设计语言
有属性，循环性，选择性
3，C有丰富的数据类型和运算符
数据类型：数据在计算机内的表现形式
基本数据类型：整型实型字符型
int float char
控制符：
%d 整型
%f 实型
%c 字符型
4，C语言的结束符为分号大括号为一个语句或函数范围
5，C语言的构成
#include<文件名。h>
#define 宏名字符
main 主函数
①预处理（以#开头) (不属于C语言)
②书写主函数（。C）
一个C语言程序是与主函数构成，主函数有且只有一个，main。
可以有或没有子函数
执行程序
从子函数开始从左到右，从上倒下。
补充：
数制
一。含义
由一组数组成且按照一定的规则对数据进行管理的制度
二。分类
二进制八进十十六
组成：
二：0 1
八：0--7
十：0--9
十六：0--9和a--f
权：根据位置不同，所表示的数值不同。表示：基数的n次幂（n从0开始）
基数：组成该数制的数字个数。
123
1*100+2*10+3*1
三。转换
1。十制数-->其它进制
规则：
整数：除以相应数制的基数然后除余倒排列。
小数：乘以相应数制的基数然后除整数正排列。
**当乘不尽时,保留前两位.
(13.5）10=(1101.1)2
2.其它进制-->十制数
规则:按权展开,相加求和.
(1101.167)8=(13.)10
3.其它进制
二<--->八
采用421算法
(001 011 011 010 101 110.001 101 011 100)2=(133256.1534)8
规则:从小数点开始向两侧每三个二进制位为一组,不足3位的,整数部分在前面补齐,小数部分在后面补齐,然后,对每一组按权展开相加求和.
八-->二
采用421反算法
将一个八进制位拆分3个二进制位.
(75462.5041)8=(111101100110010.101000100001)2
二-->十六
采用8421算法
规则:从小数点开始向两侧每四个二进制位为一组,不足4位的,整数部分在前面补齐,小数部分在后面补齐,然后,对每一组按权展开相加求和.
(1001 1110 1110 1100 1010.1101 1001 0100)2=(9eca)16
十六-->二
采用8421反算法
将一个十六进制位拆分4个二进制位.
(10afd)16=(10000101011111101)2
八<--->十六
借助二,十进制
第二讲数据类型常量变量

一.数据类型:
数据在计算机内的表现形式
整型
基本数据单精度
实型(浮点型)
双精度
字符型

结构体
构造类型共用体
数组

指针型,空类型.
二.常量
<一>.含义,在程序招待过程中,其值不变的量.
<二>.使用形式
1.字面量.
s=2*P*r;
2.宏符号
#define X 3.141592627
int x;
<三>分类
整型常量实型常量字符型常量字符串常量
A:整型常量
1.表示形式
八进制十进制十六进制(二进制不能表示整型常量)
2.书写格式
十进制:由0--9组成,不能以0开头.5 6
八进制:由0--7组成,必须以0开头.eg:05 07
十六进制:由0--9和a--f组成,必须以0x开头. 0x5 0xa 0xa01
3.分类,范围,空间,控制符
十进制:
-5 1111111111111111
5 0000000000000101

123
0 1 999
有符号 (signed) int x; %d -32768----32767
短整型(2B)
无符号 unsigned int x; %u 0----65535
有符号 (signed) long (int) x; %ld -2147483648----2147483647
长整型(4B)
无符号 unsigned long (int) x; %lu 0-----429......

八进制(无符号)
符合整数的定义规则 .
短无(2B): %o 0---0177777
长无(4B):%lo 0---037777777777
十进制(无符号)
符合整数的定义规则 .
短无(2B): %x 0---0xffff
长无(4B):%lx 0---0xffffffff
B:实型常量
1。表示形式
十进制指数形式
2.十进制
由0--9组成,必须有小数点,小数点前面或后面有数据.
单精度:float %f 10(-38)----10(38) 4B
双精度:double %lf 10(-308)---10(308) 8B
3.指数形式
阶码标志:E(e)代表10
double x=1.23457e+3;
必须有阶码标志E(e),阶码标志前和后必须有数据,且前面是整数或实数,指数部分:必须是整数.
%e 与%f一致小数点后保留6位,且E也算一位
C:字符型常量
1.书写格式
由一对单引号括起的任意一个字符.
2.分类
ASCII码字符(共256个)
'a'---'z'[97--122] 'A'--'Z'[65--90] '0'---'9' [48--57]
ASCII码值:每个字符对应的十进制整数.(无符号) 0---255
main(){ char c; scanf("%c",&c); printf("%c",c-32);}
if(c>=97&&c<=122)
printf("%c is xiaoxie",c);
else if(c>='A'&&c<='Z')
printf("%c is da xie",c);
else if(c>='0'&&c<=57)
printf("%c is shuzi",c);
else
printf("%c is qita",c);
转义字符
书写格式:以\开头,用一对单引号括起一个或多个字符,但是表示是一个字符.
分类:
'\+字母':作用:主要控制光标.
'\n':光标回车换行.
'\t':光标跳到下一个制表位
'\r':光标回到行首
'\b':光标左退一列
printf("******\n*******");
'\+标点':作用:控制输出一个标点符号
'\'':输出一个单引号
'\"':输出一个双引号
'\\':输出一个反斜杠
'\+数字': 作用:表示一个ASCII码字符.
'\0ddd':八进制转义字符:最多三位八进制数*****0可以省略.
'\xdd':十六进制转义字符:最多二位十六进制数
'\0123' '\123'
'\xa1'
printf("%c",'\61');
3.范围(1B)
有符号:-128----127
无符号:0--255
char c=-5;
printf("%c",c);

D：字符串常量
书写格式：由一对双引号括起任意零个1个或多个字符。
字符串的长度：组成该字符串的字符个数。
字符串结束标志：'\0'
空间:串长度+1个空间.
控制:%s
char x[100];
scanf("%s",x);
printf("%s",x);
printf("%s","kdfjlkdsjfsdls");
printf("%s","zheng");
"":空串.
三.变量
1.其值在执行程序中可以改变的量.
2.定义格式
存储类型数据类型变量名1,变量名2,......变量名n;
int x,y,z;
存储类型:变量开辟空间的类型.
auto:(默认)自动型该变量的默认值为随机值.
static:静态型该变量的默认值为0值.
regiester:寄存器型该变量的默认值为随机值.
extern:外部参照型该变量的默认值为0值. (我们使用省略extern型)
static int x;
printf("%d",x);
aaa.prg
a1.c int x;
a2.c extern int x;
a3.c
int x;
main()
{
int x;
}
变量名:
a:多个变量之间用,隔开;
b:相同类型的变量可以写在同一个语句中;
int a,b,c;
c:变量命名
必须符合合法的用户标识符
标识符:用来表明或表示变量或函数的名字或类型的符号.
关键字:用来标识类型的标识符.(32个关键)
存储类型,数据类型,流程类 ,运算符类(sizeof)
标识符:由字母,数字,下划线组成,不能以数字开头,不能与关键字重名.
int if;
_a1;
1a
a 1;
main()
{
int x,X;
float x;
****不能与同一范围内的变量名重名.*****
3.给变量赋值.
通过两种:
赋值表达式: =
输入函数:scanf()
x=3;
scanf("%d",&x);
a:赋值表达式
格式: 变量名=表达式;
左边必须是变量名,右边赋值给左边,并将左边变量的值覆盖.当一个变量进行多次赋值时,该变量只能保留最一次所赋的值.
main()
{
int x;
x=2;
x=5;
scanf("%d",&x);
printf("%d",x);
getch();
}
int x,y,z;
x=2;
y=3;

z=x;
x=y;
y=z;

x=3;
y=2;
b:scanf()
格式:scanf("控制符",地址项)
scanf("%d%f%c",&x,&y,&z);
3. 数据类型之间转换(两个自动,一个强制)
a:在赋值时,右边数据的类型自动转换成左边变量的类型.
int x;
x=1.23;
float x;
x=10;
char c=65;
int x='a';
int x=32768;
printf("%d,%u",x,x);
b:运算时,数据类型低的转换成数据类型高的(占空间的字节数)
int x;
float y;
printf("%f ",x+y);
c:强制转换
格式:(数据类型)表达式
数据类型:将要转换成的类型
表达式:要转换的对象.
(float)x+y
(float)(x+y)
x+(float)y
float x=12.345,y;
y=x-(int)x;
printf("%f",x);
(int)x%2==0
第三讲运算符及表达式
目:根据运算对象对运算符分为:单目,双目,三目.
表达式:简单和复杂表达式
简单:无运算连接的式子. 3 x (1)
复杂:有运算连接的式子. x+y x=3 x<y
一.算术运算符 +(正)-(负)+ - / * %
规则:
/ :当运算对象都为整数时,结果取整的.若其中一个为实型,结果为实型. 1/2.
%(取余/模):要求:运算对象必须为整型.
int x,y;
x%y
x=123
x%10;
x/10%10
x/100
表达式
式子的类型:与运算对象中占空间最大的一致.
优先级:正,负-->*/%-->+,-
结合性:单目:从右向左;双目:从左向右.
- - -5
x%2/y*z
二.赋值运算符 = += -= /= *= %=(自反赋值)
规则: s=5
自反赋值:左边和右边先按指定的运算符进行运算,然后再赋值给自己.*****左边必须先有值.
x=2;
x+=5
x=x+5;
表达式:
表达式的值与左边变量的值一致.
printf("%d",x=5);
结合性:从右向左
int x=3;
x+=x-=1;
三.关系运算符 < > <= >= == !=
规则:.
表达式的值:逻辑值,当判断成立时,得到逻辑值真值(用1表示),不成立时,得到逻辑值假值(用0表示)****因为C语言中没有逻辑型数据****
类型:整型.
int x,y;
x=3;
y=4;
printf("%d ",x<y);
c<='z'&&c>='a' 'z'>=x>='a'
优先级:< > <= >= -->== !=
结合性:从左向右
x>y>z x>y && x>z
四.逻辑运算符 &&(逻辑与) 双目 ||(逻辑或) 双目 !(逻辑非）单目
规则:
格式:表达式1&&/||表达式2
&&:表达式1和表达式2必须都为真值(非零值),整个逻辑与表达式才成立.产生逻辑值真值(用1表示)
如果表达式1或表达式2其中一个是假值(0值),整个逻辑与表达式不成立.产生逻辑值假值(用0表示)
x= x=5&&6<9;
||:表达式1或表达式2成立,则整个式子成立,产生真值(用1表示).若两个式子都为假值,整个逻辑或表达式为假(用0表示)
x>='a'||x<='z'
!:格式: !表达式
当表达式为真(非零值)值,逻辑非表达式为假(用0表示)
当表达式为假(零值)值,逻辑非表达式为真(用1表示)
x=!(4>5)
优先级:!-->&&-->||
x>='a'&&x<='z' || x>='A'&&x<='Z'
*********
&&:如果表达式1为假了,系统不对表达式2进行计算了
||:如果表达式1为真了,系统不对表达式2进行计算了
int x,y;
x=3;
y=4;
x= x<y&&!5;
x,y?
x=x>y||x=9
x,y?
对&&和||而言:不是按优先级计算,而是先计算表达式1,再计算表达式2.
结合性:单目:从右向左
双目:从左向右
! ! ! ! !5
表达式的值:逻辑值
类型:整型.
int x,y;
scanf("%
if(x>y)
五。自增/减运算符 ++ -- 单目
规则：
表达式++ 表达式-- 后缀表达式
++表达式 --表达式前缀表达式
main()
{
int x;
x=2;
printf("%d",x++);
x=2;
printf("%d",++x);
}
变量的值：会自动的增/减1；
表达式的值：
后缀表达式：与变量改变之前值一致。
前缀表达式：会与变量的值一致增/减1；
表达式：
x++ x=x+1 x+=1
六。条件运算符( ? : )三目
规则：
表达式1？表达式2：表达式3
x>y?printf("%d",x):pritnf("%d",y);
int x,y;
w=x>y?x:y;
printf("%d",w);
int x,y;
if(x>y)
printf("%d",x);
else
printf("%d",y);
先计算表达式1，若产生非零值，则执行表达式2，并将表达式2的值作为整个条件表达式的值，若产生
零值，则执行表达式3，并将表达式3的值作为整个条件表达式的值(若执行表达式2，不执行表达式3）
int x,y,w;
x=5;
y=4;
w=x>y?x++:y++;
printf("%d,%d,%d",w,x,y);
if(x>y)
x++;
else
y++;
x,y?
优先级:
单目(++,--,-+!)-->算术双目-->关系-->逻辑运算-->条件-->赋值->逗号.
结合性:从右向左分出正确的表达式,从左向右计算.

?: ? ?: : ? :
w=x>y? x>z?x: z : y>z?y: z
3个
w,x,y,z
if(x>y)
if(x>z)
w=x;
else
w=z;
else
if(y>z)
w=y;
else
w=z;
七.逗号 , 双目
作用:分隔,运算符
格式:表达式1,表达式2
规则:从左向右算,取最后一个表达式的值为整个逗号表达式的值.
int x=5,y;
y=x++,--x,x,x+1,x;
x,x+1,x,(y=x++,++x);
y=(x++,--x,x,x+1,x);
printf("%d",(x,y));
第四讲流程控制语句
顺序循环选择
一.选择语句
if..else 和 switch
作用:根据条件执行程序的某一部分.
A:if...else
1.格式
if(条件表达式)
{
语句组1;
}
else
{
语句组2;
}
注意:
a:if,else为关键字必须为小写.
b:条件表达式:一般写关系或逻辑表达式.
c:else可选项,{}当执行语句只有一句时,可以省略.
2.执行过程
首先计算条件表达式的值,若为非零值,则执行if分支,否则,若有else分支,则执行else,没有时,执行下面的其它语句.
3.嵌套
在if或else分支中又出现if..else语句.
a:在else中出现if..else
if( )
.....
else if( )
.....
else if( )
.....
else
......
b:在if分支中出现if...else
if1( )
if2( )
if3( )
if4( )
.....
else4
.....
else3
.....
else2
......
else1
........
c:在if和else中出现if...else
if( )
if( )
....
else
....
else
if( )
....
else
....
if(x%4==0&&x%100!=0||x%400==0)
if(x%4==0)
if(x%100==0)
if(x%400==0)
printf("run");
else
printf("ping");
else
run;
else
ping

if(x>y)
if(x>z)
w=x;
else
w=z;
else
if(y>z)
w=y;
else
w=z;
B:多开关语句switch
格式
switch(表达式)
{
case 常量表达式1:语句组1;[break;]
case 常量表达式2:语句组2;[break;]
case 常量表达式3:语句组3;[break;]
................n:.....n;[break;]
default :语句组n+1;
}
注意:
a:表达式的类型必须与常量表达式的类型一致.整型或字符型.
b: break;是可选项, 当遇到break表示该语句执行完毕.
c:default是可选项.{}不可省略.
d:同一个switch语句中,常量表达式的值不能重复.
int x,y;
char w;
scanf("%d%d%c",&x,&y,&w);
switch(w)
{
case '+':printf("%d",x+y);break;
case '*':printf("%d",x*y);break;
case '/':printf("%d",x/y);break;
case '-':printf("%d",x-y);break;
default:printf("wu ci yun suan fu");
}
2.执行过程
......
3.嵌套.
char c;
scanf("%c",&c);
switch(c>='a'&&c<='z')
{
case 0:switch(c>='A'&&c<='Z')
{
case 0:switch(c>='0'&&c<='9')
{
case 0:printf("qita");break;
case 1:pritnf("shuzi");break;
}break;
case 1:printf("daxie");break;
}break;
case 1:printf("xiaoxie");break;
}
二.循环语句
for while do...while
作用:根据条件重复执行程序的某一部分.
A:for语句
1.格式
for(表达式1;表达式2;表达式3)
{
循环体语句;
}
for(x=1;x<=10000;x++)
{
printf("%d",x);
}
注意:
a:表达式1:给循环变量赋初值
b:表达式2:决定是否应该进入循环的条件,一般为关系或逻辑表达式.
c:表达式3:给变量重新赋值.
d:{}可以省略.3个表达式均可省略.同时省略 for(;;)无限循环.
2.执行过程
首先执行表达式1给变量赋初值,然后再判断表达式2是否成立.若成立则进入循环体,当执行到}表示一次循环体执行完毕.再执行表达式3给变量赋新值,然后再判断表达式2是否成立.若成
立,再进入循环体,否则,表示该语句执行完毕.
1.求1---100和
2.接收10个实数,对小数部分求和.

B:while语句
a.格式
while(表达式)
{
循环体;
}
注意:{}当循环体只有一句时,可以省略.表达式与表达式2一样,但不能省略.while(1)===for(;;)无限循环.
for(i=1;i<=100;i++)
printf("%d",i);

int i;
i=1;
while(i<=100)
{
printf("%d",i++);
}
补充:
输入/出单个字符的函数.**必须预处理<stdio.h>
getchar()和putchar()
格式
变量名=getchar();
putchar(变量名/常量);
main()
{
char x;
scanf("%c",&x);
printf("%c",x);
x=getchar();
putchar(x);
}
C.do ...while
a:格式
do
{
循环体;
}while(表达式);
注意:
;{}均不可省略.先执行一次循环体,再判断表达式是否成立.
至少执行一次.

main()
{
int i;
i=1;
do
{
printf("%d",i);
}while(++i<=100);
D:嵌套
for(i=1;i<=3;i++)
for(j=1;j<=3;j++)
for(k=0;k<=59;k++)
{
printf("%d:%d:%d",i,j,k);
delay(1);
}
****
***
**
*
for(i=1;i<=4;i++)
{
for(j=1;j<=5-i;j++)
printf("*");
putchar('/n');
}

1!+2!+3!+4!+....n!
阶乘。
三.转移
break;
作用：只能用在循环体或switch语句中。
用在循环体中，为了终止其所在的循环体。
while(c!='*')
c=getchar();
if(c=='*')
break;
continue;
只能用在循环体中，提前结束本次循环体语句，而进入下一次循环体。

for(i=1;i<=100;i++)
{
if(i%2)
continue;
printf("%d",i);
}
***********************************************
数组前的笔记
+qq619740933，能帮你讲得尽量帮你讲明白

㈦ C语言入门知识

char a[20],b[20],c[20];上面的a,b,c都是数组变量,在定义时已经为其分配栈内存,而char (*str1)[20],(*str2)[20],(*str3)[20]; 只是分配了4个字节的内存来保存指针变量(即变量本身),而指针的值(即指向)还没有,所以这些指针还不能保存数据!--------------char (*str1)[20],(*str2)[20],(*str3)[20]; str1 str2 str3均为指针,都指向长度为20的char数组.你只定义了指针,但是没有对其进

㈧ C语言考试教程◆全国计算机等级考试二级C语言视频教程（完整版) 下载

计算机等级考试二级C语言

首先我们先看下软件展示图，最后是软件！

图：

3、未来教育2017二级msoffice模拟软件

以其模式的高专业度，题库权威度而闻名业界，它聚合历年真题加以分析从而提出权威预测，效果非常不错。

2、捷成全国计算机等级考试练习系统。

上机考试系统提供了历届考试题100套，并附有试题分析和参考答案，可以帮助考生熟悉考试模式，提高应试能力，测试实际操作和应变能力，自己评定成绩，对正式考试时能否通过进行初步的估计。

1、全国计算机等级考试超级模拟软件。

汇聚了多年开发全国计算机等级考试模拟软件的丰富经验，并综合有经验的命题专家、教授和全国各地考点一线教师的建议基础上研制而成。本套软件采用模拟考试形式，以大量的习题练习，强化考生的应考能力。

㈨ c语言的基本课程是什么

全书共12章，第1章计算机程序设计的含义，第2章C语言程序的基本结构，第3章C语言的基本数据类型与简单I/0，第4章C语言的语句特征，第5章函数，第6章变量的存储属性，第7章编译预处理与工程，第8章C语言的数组及其应用，第9章指针变量及其属性，第10章结构体、共用体数据及其应用，第11章C语言的文件I，0及其应用，第12章C语言的位运算与低级操作。
替你了，懒。

㈩ C语言知识总结

c语言概要
第一章、概述
1、 c语言的基本知识
1.1、 c语言的执行步骤
编辑-程序代码的录入，生成源程序*.c
编译-语法分析查错，翻译生成目标程序*.obj
（语法或逻辑错误，从第一个开始改，变量定义，语句格式，表达式格式等）
链接-与其他目标程序或库链接装配，生成可执行程序*.exe
执行
1.2、 main函数的基本知识
main（）函数的位置
c程序总是从main( )函数开始执行
一个c程序可以包含一个主函数，即main（）函数；也可以包含一个main()函数和若干其它函数
1.3、 c程序的结构
函数与主函数
程序由一个或多个函数组成
必须有一个且只能有一个主函数main()
程序执行从main开始，在main中结束，其他函数通过嵌套调用得以执行
程序语句
C程序由语句组成
用“；”作为语句终止符
注释
//
或
/* */ 为注释，不能嵌套
不产生编译代码
1.4、c 程序书写的规则
习惯用小写字母，大小写敏感
不使用行号，无程序行概念：通常一个语句占一行
可使用空行和空格
常用锯齿形的书写格式；同一层次结构的语句上下对齐。
第二章、基本数据类型与运算
2.1、c程序的数据类型
注意类型和变量含义的不同（类型是固定好的名字，变量是自己起的名字）
变量占用的存储空间
数据类型
基本类型：整型、字符型、浮点型（单精度型，双精度型）
构造类型：数组类型、结构体类型
指针类型
空类型
注意基本类型赋初值的方式
基本数据类型的表示形式
整形数据
十进制：以非0数字开头，如：123，-9，0
八进制;以0数字开头，如：0123，067
十六进制：以0x开头，如：0x123,0xff
实型数据
十进制：必须带小数点，如：123.0，-9.0
指数形式;如：1.23E3，0.9e-2,5e2
字符型数据
普通字符：如：’a’,’2’,’H’,’#’
转义字符：如：’\n’,’\167’,’\xlf,’\\’
（实现几列的对齐：指定宽度。如%100\ ‘\t’制表位）
（字符串长度。“abc\n\t\\” strlen 6; sizeof 7）
基本数据类型的存储长度
整型
Int 字节数 2 位数 16 数的表示范围 -32768—32767
Short 2 16 -32768—32767
Long 4 32 -2147483648—2147483647
实型
Float 4 32 3.4e-38---3.4e38
Double 8 64 1.7e-308---1.7e308
字符型
Char 1 8 -128----127
2.2、标识符命名规则
C语言标志符命名规则
标识符有数字，字母，下划线组成
标识符的首字符必须为字母和下划线
标识符不能为c语言的保留字（关键字）
如：auto extern sizeof float static case for struct char goto switch continue in typedef const if union default long unsigned do register void double return else short while enum signed
算术运算符 + - * / %
关系运算符 > < == >= <= !=
逻辑运算符！ && ||
位运算符 << >> ~ | ^ &
赋值运算符 = 及其扩展赋值运算符
条件运算符 ? :
逗号运算符，
指针运算符 * &
求字节数运算符 sizeof
强制类型转换运算符（类型）
分量运算符 . ->
下标运算符 [ ]
其他如函数调用运算符()
运算符的优先级
由高到低：单目运算符，算数运算符，关系运算符，赋值运算符
说明：单目运算符：自增运算符，自减运算符，类型装换运算符。结合方向：自右至左
如：++--I 先—i.。
算术运算结合方向自左至右
2.3基本运算和表达式
关系表达式和逻辑表达式
(a>b)&&(x>y) (a==b)||(x==y) !=a||(a>b)
A&&b.a为0.不执行b
A||b a为1.不执行b
在 c 中逻辑运算结果：1代表“真”，0代表“假”；
判断一个表达式是否真：0代表“假”，非0代表“真”
条件表达式逗号表达式
如：k=5,k++
逗号值为5；k为6.
表达式1？表达式2 ：表达式3
K=5>6 ? 1 : 0
2.4、混合运算的数据类型转换
2/3+0.5 双精度浮点型
第三章、顺序结构程序设计
3.1、c语句的分类
简单语句
表达式语句表达式+分号
空语句只有分号的语句
复合语句用花括号将若干语句括起来
流程控制语句
选择语句 if ,switch
循环语句 while, do while , for
转移语句 break ,continue ,return goto
3.2、格式输入函数scanf
一般形式：scanf(“格式控制字符串“，地址列表)；
使用scanf函数时，需要注意：
格式字符的个数必须与输入项的个数相同，数据类型必须一一对应，非格式字符串（说明性的）要原封不动的输入。
输入实行数据时，可以不带小数点，即按整型数据输入
数值型数据与字符或字符串混合输入时，需要注意输入方式。
3.3、格式输出函数printf
Printf（“格式控制字符串“，输出列表）；
指定输出格式，由格式字符串和非格式字符串两种组成，非格式字符串照原样输出。
%[标志][输出最小宽度][.精度][长度]类型
标志：- 左对齐；+ 右对齐；
%f, %d, %c, %s
3.4、其他输入输出函数
Putchar getchar puts gets
第四章、选择结构程序设计
If选择结构
单分支
If(表达式)
语句
双分支
If(表达式)
语句1
Else
语句2
多分支
If （表达式1）
语句1
Else if（表达式2）
语句2
。。。
Else if(表达式m)
语句m
Else
语句n
Switch（表达式）
{
Case 常量表达式1：语句1；break；
Case 常量表达式2：语句2；break；
。。。
Case 常量表达式m：语句m；break;
Default:语句n；break;
}
注意break的使用
第五章、循环结构程序设计
循环三要素
初始条件；终止条件；在初始条件和终止条件间反复做某件事情（循环体）
While(表达式)
语句

Do
语句
While(表达式);

For(循环体变量赋初值；循环条件；循环变量增量)
( for( ) ; // ; 进行时间延迟。在信息交换等时用。如for(i=0,i<100) ; 互相通讯的时间延迟。 Delay )
Break语句：不能用于循环语句和switch语句之外的任何其他语句；跳出循环。
Continue语句：跳过循环体中剩余的语句而强行执行下一次循环；跳出本次循环。
第六章、函数与编译预处理
6.1、函数的定义和调用
类型标识符函数名（形式参数列表）
{ 声明部分
语句
}
例：
Int max (int x,int y)
{int z; Z=x>y?x:y; Return(z);}
6.2、局部变量和全局变量
注意函数中静态变量的定义和使用
6.3、变量的存储类型
局部变量的存储类型
自动变量(auto) 动态存储
局部静态变量（static）静态存储
寄存器变量(register) 静态存储
全局变量的存储类型
自动变量（auto）动态存储
外部变量（extern）静态存储
全局静态变量（static ）静态存储
Extern 外部引用
Static 不能用extern 引用。
第七章、数组
7.1、一维数组的定义和使用
特别需要注意循环体的初值，终止条件
例：
Main()
{
Int I,a[10];
For(i=0;i<=9;i++)
A=I;
For(i=9;i>=0;i--)
Printf(“%d”,a);
}
注意下标问题
7.2、二维数组的定义和使用
二维数组的初始化
例如：
Int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
Int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Int a[ ][4]={{1,2,3,4},{5},{9,10,11,12}};
例如：int a[3][3]={{1},{2},{3}};
是对每一行的第一列元素赋值，未赋值的元素取0
7.3、字符数组和字符串
字符串用字符数组来处理，结束标志符 ‘\0’
如：char c[ ]={“I am happy”};
用字符串常量使字符数组初值化
Char c[ ]={‘I’,’ ‘,’a’,’m’,’ ‘,’h’,’a’,’p’,’p’,’y’,’\0’};
第八章、指针
8.1、地址和指针的概念
Int I;
Int *i_point;
8.2、指针变量和变量的地址
操作符：* &
8.3、指针和一维数组
若有定义
Int a[10];
Int *p=a;
分析下面表达式的含义：
A, &a,
*(a+i), a+I,
*(p+i), p+i
A=*(a+i)=*(P+i)
&a=a+i=p+i
8.4、指针与字符串
Main()
{
Char string[ ]=”I love china!”;
Printf(“%s\n”,string);
}
Main()
{ char *string=”I love china!”;
Printf(“%s\n”,string);
}
8.5、指针变量作为函数参数
形参的定义方式；实参的形式；参数的传递方式。
第九章、结构体
9.1、结构体类型和变量的定义
Struct 结构体名
{成员列表}；
Struct student
{char stuNO[8]; Char name[20]; Char sex; Int age; Float score; Char addr[30]; };

Stuct student
{char stuNO[8]; Char name[20]; Char sex; Int age; Float score; Char addr[30]; };
Struct student stu1, stu2;
9.2、结构体变量的引用
一般形式为：
结构体变量名.成员名
9.3、结构体数组
结构体数组结构体数组元素.成员名
指向结构体的指针变量
（*p）.成员名
p->成员名
其他
Strcpy(字符数组1，字符串2)
Strcat(字符数组1，字符数组2)
Strcmp(字符串1，字符串2)
Strlen（字符数组）

07第四讲c语言基础知识

(3)07第四讲c语言基础知识扩展阅读：

与07第四讲c语言基础知识相关的内容