大学c语言知识点总结

大学c语言知识点总结（共11篇）

1.大学c语言知识点总结 篇一

第一节、对C语言的基础认识

1、C语言编写的程序称为源程序，又称为编译单位。

2、C语言书写格式是自由的，每行可以写多个语句，可以写多行。

3、一个C语言程序有且只有一个main函数，是程序运行的起点。

第二节、熟悉vc++

1、VC是软件，用来运行写的C语言程序。

2、每个C语言程序写完后，都是先编译，后链接，最后运行。（.c—.obj—.exe）这个过程中注意.c和.obj文件时无法运行的，只有.exe文件才可以运行。（常考！）

第三节、标识符

1、标识符（必考内容）：

合法的要求是由字母，数字，下划线组成。有其它元素就错了。

并且第一个必须为字母或则是下划线。第一个为数字就错了

2、标识符分为关键字、预定义标识符、用户标识符。

关键字：不可以作为用户标识符号。main define scanf printf 都不是关键字。迷惑你的地方If是可以做为用户标识符。因为If中的第一个字母大写了，所以不是关键字。

预定义标识符：背诵define scanf printf include。记住预定义标识符可以做为用户标识符。

用户标识符：基本上每年都考，详细请见书上习题。

第四节：进制的转换

十进制转换成二进制、八进制、十六进制。

二进制、八进制、十六进制转换成十进制。

第五节：整数与实数

1）C语言只有八、十、十六进制，没有二进制。但是运行时候，所有的进制都要转换成二进制来进行处理。（考过两次）

a、C语言中的八进制规定要以0开头。018的数值是非法的，八进制是没有8的，逢8进1。

b、C语言中的十六进制规定要以0x开头。

2)小数的合法写法：C语言小数点两边有一个是零的话，可以不用写。

1.0在C语言中可写成1.

0.1在C语言中可以写成.1。

3）实型数据的合法形式：

a、2.333e-1 就是合法的，且数据是2.333×10-1。

b、考试口诀：e前e后必有数，e后必为整数。请结合书上的例子。

4） 整型一般是4个字节, 字符型是1个字节，双精度一般是8个字节：

long int x; 表示x是长整型。

unsigned int x; 表示x是无符号整型。

第六、七节：算术表达式和赋值表达式

核心：表达式一定有数值！

1、算术表达式：+，-，*，/，%

考试一定要注意：“/” 两边都是整型的话，结果就是一个整型。 3/2的结果就是1.

“/” 如果有一边是小数，那么结果就是小数。 3/2.0的结果就是0.5

“%”符号请一定要注意是余数，考试最容易算成了除号。）%符号两边要求是整数。不是整数就错了。[注意!!!]

2、赋值表达式：表达式数值是最左边的数值，a=b=5;该表达式为5，常量不可以赋值。

1、int x=y=10: 错啦，定义时，不可以连续赋值。

2、int x,y;

x=y=10; 对滴，定义完成后，可以连续赋值。

3、赋值的左边只能是一个变量。

4、int x=7.7；对滴，x就是7

5、float y=7；对滴，x就是7.0

3、复合的`赋值表达式：

int a=2；

a*=2+3；运行完成后，a的值是12。

一定要注意，首先要在2+3的上面打上括号。变成（2+3）再运算。

4、自加表达式：

自加、自减表达式：假设a=5，++a（是为6）， a++（为5）；

运行的机理：++a 是先把变量的数值加上1，然后把得到的数值放到变量a中，然后再用这个++a表达式的数值为6，而a++是先用该表达式的数值为5，然后再把a的数值加上1为6，

再放到变量a中。 进行了++a和a++后 在下面的程序中再用到a的话都是变量a中的6了。

考试口诀：++在前先加后用，++在后先用后加。

5、逗号表达式：

优先级别最低。表达式的数值逗号最右边的那个表达式的数值。

（2，3，4）的表达式的数值就是4。

z=（2，3，4）(整个是赋值表达式) 这个时候z的值为4。（有点难度哦！）

z= 2，3，4 （整个是逗号表达式）这个时候z的值为2。

补充：

1、空语句不可以随意执行，会导致逻辑错误。

2、注释是最近几年考试的重点，注释不是C语言，不占运行时间，没有分号。不可以嵌套！

3、强制类型转换：

一定是 （int）a 不是 int（a），注意类型上一定有括号的。

注意（int）（a+b） 和（int）a+b 的区别。 前是把a+b转型，后是把a转型再加b。

4、三种取整丢小数的情况：

1、int a =1.6；

2、(int)a；

3、1/2； 3/2；

第八节、字符

1）字符数据的合法形式:：

‘1’ 是字符占一个字节，”1”是字符串占两个字节(含有一个结束符号)。

‘0’ 的ASCII数值表示为48，’a’ 的ASCII数值是97，’A’的ASCII数值是65。

一般考试表示单个字符错误的形式：’65’ “1”

字符是可以进行算术运算的，记住： ‘0’-0=48

大写字母和小写字母转换的方法： ‘A’+32=’a’ 相互之间一般是相差32。

2）转义字符：

转义字符分为一般转义字符、八进制转义字符、十六进制转义字符。

一般转义字符：背诵�、、’、”、。

八进制转义字符： ‘141’ 是合法的， 前导的0是不能写的。

十六进制转义字符：’x6d’ 才是合法的，前导的0不能写，并且x是小写。

3、字符型和整数是近亲：两个具有很大的相似之处

char a = 65 ;

printf(“%c”, a); 得到的输出结果：a

printf(“%d”, a); 得到的输出结果：65

第九节、位运算

1）位运算的考查：会有一到二题考试题目。

总的处理方法：几乎所有的位运算的题目都要按这个流程来处理（先把十进制变成二进制再变成十进制）。

例1： char a = 6, b;

b = a<<2; 这种题目的计算是先要把a的十进制6化成二进制，再做位运算。

例2： 一定要记住，异或的位运算符号” ^ ”。0 异或 1得到1。

0 异或 0得到0。两个女的生不出来。

考试记忆方法：一男(1)一女(0)才可以生个小孩(1)。

例3： 在没有舍去数据的时候，<<左移一位表示乘以2；>>右移一位表示除以2。

 

2.大学c语言知识点总结 篇二

数据排序是计算机编程过程中经常会遇到的一个问题,同样C语言中关于排序问题的算法也有多种。本文主要对一些常见的排序算法进行一个归纳总结,方便初学者对这一问题有一个全面的了解。

所谓数据排序,就是将一组无序的数据,按照其中的某个关键字的大小,递增或递减的排列成有序的数据序列。在C语言的学习过程当中,经常会碰到关于整数、浮点数、字符以及字符串的排序问题。一般的排序方法有:冒泡排序、选择排序、插入排序、shel(希尔)排序、快速排序、堆排序等。下面就通过具体的例子,对这些排序方法的基本思想、执行过程、算法代码进行一个总结分析。

2 各种排序算法的分析

2.1 冒泡排序

冒泡排序法是C语言当中最为常见和通用的一种排序方法。

2.1.1 基本思想

在待排序的一组数中,相邻的两个数两两比较后发现它们的顺序与排序要求相反时,就将它们互换(即:如果从小到大排序,则两两比较时,让较大的数往下沉,较小数往上冒)。如此下去,直至最终完成排序。冒泡排序过程中,如果对N个数进行排序的话,需要进行比较的轮数是N-1轮,每轮进行N-1-i次。由于在排序过程中,它的工作看起来像冒泡,所以称作冒泡排序。

2.1.2 算法代码

例:对数组aa[5]={8,5,10,7,3}的元素从小到大进行排序。

该例子用冒泡法实现的代码段如下:

2.1.3 执行过程

第一轮:8,5,10,7,3->5,8,10,7,3->5,8,7,10,3->5,8,7,3,10(交换3次)

第二轮:5,8,7,3,10->5,7,8,3,10->5,7,3,8,10(交换2次)

第三轮:5,7,3,8,10->5,3,7,8,10(交换1次)

第四轮:5,3,7,8,10->3,5,7,8,10(交换1次)

2.1.4 分析

在程序执行过程中,关系到算法性能的主要因素是循环和交换的次数,次数越多,性能越差。

对上面这个例子中包含5个元素的数组采用冒泡法进行排序,总共进行交换的次数是3+2+1+1=7次。冒泡法的特点是原理简单,但其缺点是交换次数多、效率低。

2.2 选择排序

2.2.1 基本思想

在待排序的一组数中,每轮将首数与后数进行两两比较,按大小进行交换,选出待排序数组中最小(或最大)的一个元素,放在已经排好序的数列的最后。如此下去,直至最终完成排序。冒泡排序过程中,如果对N个数进行排序的话,需要进行比较的轮数是N-1次,每轮从i+1开始到N-1为止。

2.2.2 算法代码

同上例:对数组aa[5]={8,5,10,7,3}的元素从小到大进行排序。

2.2.3 执行过程

第一轮:8,5,10,7,3->3,5,10,7,8(交换1次)

第二轮:3,5,10,7,8(交换0次)

第三轮:3,5,10,7,8->3,5,7,10,8(交换1次)

第四轮:3,5,7,10,8->3,5,7,8,10(交换1次)

2.2.4 分析

对上面这个例子中包含5个元素的数组采用冒泡法进行排序,总共进行交换的次数是1+0+1+1=3次。选择法的循环过程与冒泡法一致,它定义了作为记号的变量k赋初值为i,依次把a[k]同后面元素比较,若有元素比a[k]小,则将该元素下标赋值给k,使得变量k当中存放的永远是最小元素的下标。最后再a[k]与a[i]交换,这样就比冒泡法省下许多无用的交换,提高了效率。

2.3 直接插入排序

2.3.1 基本思想

在待排序的一组数中,先比较前两个数,按大小顺序排列好,然后每次从后面的无序数中取出第一个元素,把它插入到前面有序数的合适位置,使有序数组仍然有序,把数组元素插完也就完成了排序。

2.3.2 算法代码

同上例:对数组aa[5]={8,5,10,7,3}的元素从小到大进行排序。

2.3.3 执行过程

第一轮:8,5,10,7,3->5,8,10,7,3(交换1次)

第二轮:5,8,10,7,3(交换0次)

第三轮:5,8,10,7,3->5,7,8,10,3(交换1次)

第四轮:5,7,8,10,3->3,5,7,8,10(交换1次)

2.3.4 分析

对上面这个例子中包含5个元素的数组采用冒泡法进行排序,总共进行交换的次数是1+0+1+1=3次。直接插入排序的特点是算法简单、容易实现。它是采用逐步增加有序元素想法,直至所有元素排列完成。如果待排序数组元素不是特别多的时候,该算法的效率快是较佳的排序方法。但对于大数组,这种算法比较慢就不大适用了。

2.4 shell排序

2.4.1 基本思想

希尔算法的本质是缩小增量排序,是对直接插入排序算法的改进。先取一个小于N的整数p作为第一个增量,将待排序的一组数按增量p分割成多个组,对每个组分别进行一趟直接插入排序。然后缩小增量p的值(一般取其一半)再排序,直到p=1时完成排序。

2.4.2 算法代码

同上例:对数组aa[5]={8,5,10,7,3}的元素从小到大进行排序。

2.4.3 执行过程

第一轮:8,5,10,7,3->8,5,3,7,10(交换1次)

第二轮:8,5,3,7,10->3,5,8,7,10(交换1次)

第三轮:3,5,8,7,10->3,5,7,8,10(交换1次)

2.4.4 分析

对上面这个例子中包含5个元素的数组采用冒泡法进行排序,总共进行交换的次数是1+1+1=3次。Shell排序的优点是不管待排序数组长度多长,在分组增量p的切割下每个子组的规模都不会太大,然后用直接插入排序效率较高。后来增量p的逐渐递减,分组数逐渐减少,而各组的记录数目逐渐增多,但由于排过序,整个数组的有序性越来越清晰,所以排序的效率依然较高。所以,希尔排序在效率上比直接插人排序有很大的改进。

2.4.5 快速排序

2.4.5. 1 基本思想

在待排序的一组数中,先选择其中一个元素作为分隔点(一般选取数组中间的那个元素),然后把比该元素小的数据放在左边,大的放在右边。再按此方法对两边的数据分别再快速排序(也就是递归调用),直到整个数组有序为止。

2.4.5. 2 算法代码

同上例:对数组aa[5]={8,5,10,7,3}的元素从小到大进行排序。

2.4.5. 3 执行过程

第一轮:8,5,10,7,3->8,5,3,7,10(交换1次)

第二轮:8,5,3,7,10->3,5,8,7,10(交换1次)

第三轮:3,5,8,7,10->3,5,7,8,10(交换1次)

2.4.5. 4 分析

对上面这个例子中包含5个元素的数组采用冒泡法进行排序,总共进行交换的次数是1+1+1=3次。快速排序是对冒泡排序的一种本质改进,其优点是运算速度快,数据移动少。缺点是算法稍复杂。快速排序法中关键是对三个参数的设定,即待排序数组元素的起始下标、最后一个元素下标以及分隔元素下标的确定。

3 总结

除了上述分析的五种常见的排序方法外,还有堆排序、归并排序等。在选择排序算法的时候,要根据待排元素数目N的大小以及元素本身的初始状态来做最佳的抉择。如果N数较小,则可采取直接插入排序或选择排序;若数组本身初始状态局部或整体有序时,则可采取冒泡排序或插入排序;若N数较大,则可采取快速排序、堆排序或归并排序。

参考文献

[1]谭浩强.C程序设计[M].3版.北京:清华大学出版社,2005.

[2]谭浩强,张基温,唐永炎.C程序设计教程[M].北京:高等教育出版社,1992.

3.C语言基础知识归纳 篇三

1.每个C程序有且只有一个主函数main()，且程序必须从main()函数开始执行，并在main()函数中结束。

2.在C语言中，用e来表示科学计数法时，规定在e的前面必须有数字，后面必须为整数。

3.用单引号括起来的一个字符常量只能存放一个字符；C语言中没有字符串变量，只能用字符数组来存储字符串。

4.外部变量在编译时由系统分配永久的内存空间，所以外部变量的类型不是自动存储类别。

5.在一个函数内的复合语句中定义的变量，只能在这个复合语句范围内有效。

6.用sizeof(int)计算int类型数据的字节数。

7.C语言运行时，首先系统检查语法的正误，再运行程序的语法；Ｃ语言中，可以在一个函数中嵌套一个函数，但是不能在一个函数中定义一个函数；只有在函数外部定义的函数才是外部函数；Ｃ语言的子程序有过程和函数两种。

8.预处理命令行的位置没有规定，只是习惯放在前面；在源文件中的可以有多条预处理命令，但一行只能写一条；宏名的大写只是习惯性的表示；宏替换不仅不占用运行时间还不分配内存空间。

9.ｆｅｏｆ函数的作用是检查文件是否结束，当结束时返回的值为非零，否则为零。

10.当定义了数组后，在给其赋值时，不能直接把字符串赋给数组名。

11.在赋值表达式中，赋值运算符“＝”右侧不能为表达式；在求余运算符中的两侧都必须为整型；在强制类型转换时，类型名应用括号括起来。

12.静态局部变量，只有当程序结束后，其值才释放。

13.当调用函数时，实参是一个数组名，则向函数传送的是数组每一个元素的地址。

14.算法的特点为有零个或多个输入，有一个或多个输出，当相同的输入时，其结果相同；算法正确的程序最终一定会结束。15.在C语言中，预处理命令行都以“#”开头；当需要时才用#include;预处理的作用就是实现宏定义和条件编译。16.当数组元素的下标超出了定义的下标范围时，系统不给出“下标越界”的字样，而是得出错误的答案，因此在编程时务必检查下标是否越界。

17.共用体变量不能作为函数的参数，也不能使函数带回共用体变量。

18.指向函数的指针变量的定义形式为：数据类型（*指针变量）（）；，因此其为指向函数的指针变量。

19.用C语言编写的代码程序是源程序，只有通过编译、连接才能进行。

20.在说明为static时，其生存期得到延长，而其作用域并没有改

变，在定义后系统会自动帮它赋值为0，static为关键字不能被用作它用。

21.频繁地使用空语句会降低程序的可读性和运算速度。22.运算符%两边都应是整数，赋值语句左边应该是变量，而非表达式，强制转换语句强制类型应加括号。

23.在逻辑运算符中，其两侧的运算符对象为任意合法的表达式即可。

24.函数fread（&Iarray，2,16，fp）的功能是，从fp所指的数据文件中读取16次2字节的数据存储到数组Iarray中。25.整个流式文件也可以随机存取数据，C语言文件中有好多函数可以达到写入数据时，未经输入数据，达到不覆盖的目的，在进行写操作时，系统会自动关闭文件。

26.使用putchar、getchat、puts、gets、printf、scanf函数时，必须在程序的开头出现包含头文件#include”stdio.h”的命令行，而使用字符串处理函数时，必须在程序的开头出现包含头文件#include”string.h”命令行，而使用数学函数时，必须在程序的开头出现包含头文件#include”math.h”的命令行。

27.一个斜杠与小于等于127任意数字按一个字符计算，一个斜杠与任意一个字符按一个字符计算。

28.一个C程序可以有一个或多个程序文件，也可以有一个或多个函数，所以一个C语言程序可以实现多种算法。

29.根据C语言规定，注释语句可以换行写，并且一个“/*”和

其后紧跟的第一个“*/”中间的部分是注释内容，且注释内容不参与程序的运行。例如：b=0;/*b=20;给b赋值*/ 则b=0。30.sizeof是求字节数的运算符，包括‘’，而strlen是求字符串的实际长度的函数，不包括‘’，以‘’作为结束。31.在函数声明时，其中的形参变量、个数、函数的类型必须一致。

32.C语言源程序经编译后生成后缀为.obj的目标程序；C程序经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件；用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中。并不是源程序中的所有行都参加编译。在条件编译形式下，相关内容只在满足一定条件时才进行编译。

33.switch括号后的表达式可以使任何表达式；case后的表达式必须是常量表达式，常量表达式中不能出现变量，且类型必须是整数、字符型或枚举型。

34.C程序必须由一个或一个以上的函数组成；函数调用可以作为一个独立的语句存在；若函数有返回值，必须通过return语句返回。

35.在C语言中，数据只能从实参单向传递给形参，称为“按值”传递。【在实参传递到形参时，是数值传递，而不是地址传递，形参中值的改变不会影响实参中的值。】

36.可以用typedef声明新的类型名来代替已有的类型名，而不能

增加新的类型。

37.在没有限制输出宽度时，一般浮点数的小数位数是6位，不管输出格式是%f或lf%均如此。

38.C语言中，函数的隐含存储类别是无存储类别。

39.当实参传递到形参时，地址传递时形参的改变影响实参。40.串的长度指的是串中的字符的个数，且其字符个数可以为零。41.C语言中数据类型有整型、实型、字符型等，实行数据分为单精度型和双精度型两种。

42.整型数组只能一个一个地输入或输出，而在字符型数组中可以对字符串整体地输入与输出。

43.C语言中，文件型指针变量的定义形式为：FILE *文件型指针名。C语言中对二进制文件的访问速度比文本文件快；C语言中，随机文件以二进制代码形式存储数据；C语言中的文本文件以ASCII码形式存储数据。

44.因为#define是宏定义的标志，而不是C语句，而printf是输出函数，因此其是C语句。

45.在实参传递给形参时，地址传递时能够改变，而数值传递时则不变。

46.在scanf函数中，必须含有输入项，并且需含有与之一一对应的转换说明符，在scanf函数的格式字符前可以加入一个正整数指定输入数据的宽度，但不可以实数指定小数位的宽度，输入项是地址表达式。

47.switch语句使用注意事项：（1）switch语句与if语句不同，仅能判断一种关系：是否恒等；（2）switch语句中case子句的常量可以使整型常量、字符型常量、枚举型数据，或是整型常量表达式，不允许变量；（3）在同一个switch中，case子句的常量不能相同，在嵌套的switch语句中，不同层次的switch之间，可有相同的常量；（4）default子句可以省略。例如：default：printf（“En”）；（5）case和default子句只能在switch语句中使用，且case和default只起标号作用，可出现在switch中的任何位置；（6）case和default子句后面的语句序列允许由多个可执行语句组成，且不必用“{}”括起来，也可以为空语句；（7）switch语句中可省略break语句，但省略后会改变流程。

48.break语句是限定转向语句，它使流程跳出所在的结构，把流程转向所在结构之后。continue语句被称为继续语句。该语句的功能是使本次循环提前结束，即跳过循环体中continue语句后面尚未执行的循环体语句，继续进行下一次循环的条件判别。

49.在C语言中，一个程序必须有一个main（）函数，但是其文件就不一定，因为其可以通过链接来实现多个子函数放到这个主函数中，主函数的位置是不固定的，可以根据自己的爱好和习惯来使用，在C语言中任何函数都不能调用主函数，且与函数的位置有关。在C程序的函数中不能定义另一个函

数。

50.在用fprintf输入时，要将其转换为二进制数形式放到文件中。51.由C语言构成的指令序列称为C源程序，源程序文件的后缀为“.c”。而目标程序为“.obj”，可执行程序为“.exe”。52.在C语言中，合法的标识符可以由字母、数字和下划线组成，且第一个字符必须为字母或下划线。

53.C语言规定必须以main作为主函数名。程序要从main（）函数开始执行，最后在main（）函数中结束。54.赋值运算符左侧的操作数必须是一个变量。

55.在C语言中，函数的实参单元与形参单元在内存中分配不同的存储单元。

56.在一个C语言源程序文件中所定义的全局变量，其作用域为：由具体定义位置和extern说明来决定范围。【全局变量是在函数外部任意位置上定义的变量，它的作用域是从变量定义的位置开始，到整个源文件结束止。当全局变量定义在后，引用它的函数在前时，应该在引用它的函数中用extern对此全局变量进行说明，以便通知编译程序该变量是一个已在外部定义了的全局变量，这时全局变量的作用域从extern说明处起，延伸到该函数末尾。】

57.C语言中，凡是以“#”号开头的行，都成为“编译预处理”。对C原程序进行编译前，由编译预处理程序对这些变异预处理命令进行处理。

58.typedef语句的作用仅仅是用“标识符”来表示已存在的“类型名”，并未产生新的数据类型。

59.共用体变量中的所有成员共享一段公共存储区，所有成员的首地址相同。在每一个时刻所有的成员中只有一个有效，即只有最后一个被赋值的成员有效，其余的成员无效。60.C语言中注释可以出现在任意位置；C语言一行内可以写多个语句，一个语句可以写在多行上；C语言编写的程序可以放在多个程序文件中。

61.标识符只能由数字、字母和下划线组成，并且只能以字母和下划线开头。

62.在用基本输出语句printf时，格式说明与输出项的个数应该相同。如果格式说明的个数少于输出项的个数，多余的输出项不予输出，如果格式说明个数多余输出项个数，则对于多余的格式项输出不定制或0。

63.二维数组定义和初始化允许省略行下标，不允许省略列下标。64.预处理命令行是在系统对原程序进行编译之前进行处理的，不是在程序执行的过程中。

65.gets和getchar函数用于从标准输入设备终端读入字符串和字符，并非从磁盘文件读入。

66.动态变量和静态变量都是内存变量，而寄存器变量不保存在内存上，而是直接存储在CPU的寄存器中。变量的存储类别有自动、静态、寄存器、外部。

67.C语言的源程序是由函数构成的，其基本单位是函数，每一个函数完成相对独立的功能，其中至少包括一个主函数；C语言的书写格式自由，一行可写多条语句，一条语句也可写在不同行上；C语言规定每个语句以分号结束。可随时添加注释，对程序没影响。

68.由高级语言编写的程序称为“源程序”，由二进制代码表示的程序称为“目标程序”。由汇编语言编写的程序称为“汇编程序”。对于计算机本身来说，它只能接收和处理由0到1的代码构成的二进制指令和数据。所以计算机能识别的程序是“目标程序”。而计算机可以直接执行的是可执行程序，即后缀为.exe的程序。

69.C语言源程序不能表示二进制，她

在C语言中，所有的数值型常量都带有符号，所以整型数量只区别整型和长整型两种形式，整型常量和长整型常量均可用十进制、八进制、十六进制3种形式表示。

70.宏名没有大小写限制。宏定义可以放在程序中的任何位置，其有效范围是从定义开始到文件结束。宏代换可以代替任何数据类型，不受数据类型的限制。函数影响运行时间，宏调用影响编译时间。

71.字符数组可以只存放普通字符，不存放字符串。此时该字符数组没有存放结束标志‘’。

4.C语言总结 篇四

--------13软件工程一班郭笑笑

------------老师：

徐

静

经过一学期的对c语言这门课程学习，我对其有了一定的了解，但是也仅仅是停留在了解的范围，对里面的好多东西还是很陌生，更多的在运用起来的时候还是感到很棘手，因为私下练习的时间太短了。

上机实验是学习程序设计语言必不可少的实践环节，特别是c语言灵活、简洁，更需要通过编程的实践来真正掌握它。对于程序设计语言的学习目的，可以概括为学习语法规定、掌握程序设计方法、提高程序开发能力，这些都必须通过充分的实际上机操作才能完成。

学习c程序设计语言除了课堂讲授以外，必须保证有不少于课堂讲授学时的上机时间，为此，结合课堂讲授的内容和进度，老师为我们安排了多次上机实验。课程上机实验的目的，不仅仅是验证教材和讲课的内容、检查自己所编的程序是否正确，还可以有以下几方面的好处：

1．加深对课堂讲授内容的理解。

2.熟悉程序开发环境、学习计算机系统的操作方法。

3．学习上机调试程序等等。我对程序调试还没有完全掌握，不能很快找出程序的错误。

因为课堂上要讲授许多关于c语言的语法规则，听起来十分枯燥无味，死记硬背也不容易记住。还有一些内容自己认为在课堂上听懂了，但上机实践中会发现原来理解的偏差，不能很好地利用学到的知识编写c语言程序，解决实际问题。总的来说在这半年的时间里，我学到了许多，但是也有很多内容是不会的。我觉得我在这一学期中掌握的内容有（收获）：

1.printf(“%*sn”,M,“字符串”+N)的用法说明 2.scanf函数的用法和说明

3.自增自减:n++、n--、++n、--n 4.进制的转换:二进制、八进制、十进制、十六进制

5.变量在内在中的存放与转换.6.3.字符-----‘’的作用:与一些字母组成转义字符,与数字组成代表八进制数.另外说明一下r,其作用是将当前位置移到本行开头,后面再输入字符时,原有的字符将会被覆盖。

7.5.逗号运算符.8..局部变量.全局变量 9..预编译处理命令

10.#define:宏定义只是在编译前对代码作简单的字符串替换,不会考虑任何错误.宏定义不是语句,后面不要加“;”.似懂非懂（不能很好地应用）： 1.退出过程.(1)continue :用于结束某次循环继续下一循环.(2)break: 用于结束循环或结束switch语句.(3)return: 用于结束某函数.(4)exit: 用于结束某一程 2.void的说明.Void代表空类型,在定义指针变量或函数时可以定义为void型,定义指针变量后可以在用的时候通过强制类型转换使其指向任何类型的数据.定义函数时,只是说明不能有返回值.如果函数中出现return就会报错.3.指针:(1).指针的加减法:指针的加减法不是作简单的加减,而是以指针变量所占的字节数为单位进行加减.(2).数组名是指针常量,不能改变其值,比如数组a[ ],如果进行a++;就会报错

(3).虽然指针变量中存放的地址是整型数据,但不能将整型数据直接赋值给指针变量,应该这样(假如p为int *型),p=(int *)1000;但禁用些法,因为你不知道1000这个单元有没有被其它单元占用,后果不可预料,同样也不能将一个指针变量的值直接赋给整形变量,也要进行强制类型转换.(4)定义指针后,在使用之前一定要先给它赋初值,切记

(5).二维数组中指针问题(int a[3] [4]),数组名a是一个指向行的指针(指向数组),而在其前面加一个 * ,*a就是指向列的指针(指向无素).a与*都是指向a[0][0];但a+1(行指针)指向a[1][0];而*a+1(列指针,和*(a+0)+1一样)却指向a[0][1];同样在a+1前加一个*就又变成列指针了,*(a+1)+2就指向a[1][2].(6),复杂类型的说明:从变量名处起,根据运算符优先级结合,一步一步分析,下面以一个比较复杂的类型(int *(*p(int))[ ])为例: 第一步,p先与()结合,说明是一个函数,第二步,()内有一个int,说明函数有一个形参为int型,第三步与*结合,说明返回的是一个指针变量,第四步与[ ]结合,说明该指针变量指向数组,第五步再与*结合,说明数组中的元素为指针型,第六步说明数组中的指针元素的类型为int型,完毕,所以这是一个返回一个由整型指针变量组成的数组的指针变量的函数。4.结构体的应用。完全不会的：

5.C语言期末总结 篇五

例10.4 指向结构体数组的指针的应用

#include struct student { int num;char name[20];char sex;int age;};struct student stu[3]={{10101，″Li Lin″，′M′，18},{10102，″Zhang Fun″，′M′，19｝，｛10104，″WangMing″，′F′，20｝｝;void main(){ struct student *p;

printf(″No.Name

sex

agen″）；

for(ｐ＝stu；ｐ＜stu＋３；p＋＋）

printf(″%5d %-20s %2c %4dn″,p->num,p->name,p->sex,p->age);

} 运行结果：

No.Name

sex

age

10101

LiLin

Ｍ

1010Zhang Fun Ｍ

10104

WangMing Ｆ

例10.5 有一个结构体变量stu，内含学生学号、姓名和3门课程的成绩。要求在main函数中赋予值，在另一函数print中将它们输出。今用结构体变量作函数参数。#include #include #define FORMAT ″%dn%sn%fn%fn%fn″ struct student { int num;

char name[20];

float score[3];};

#include #include #define FORMAT ″%dn%sn%fn%fn%fn″ struct student { int num;

char name[20];

float score[3];};

void main(){ void print(struct student);

struct student stu;

stu.num=12345;

strcpy(stu.name,″LiLin″);

stu.score[0]=67.5;

stu.score[1]=89;

stu.score[2]=78.6;

print(stu);} void print(struct student stu){ printf(FORMAT，stu.num，stu.name，stu.score[0]，stu.score[1]，stu.score[2]）；

printf（″n″）；} 运行结果： 12345 Li Li 67.500000 89.000000 78.599998 例10.6 将上题改用指向结构体变量的指针作参数。#include struct student { int num;

char name[20];

float score[3];}stu={12345, ″LiLi″,67.5,89,78.6};void main(){ void print(struct student *);

print(&stu);}

void print(struct student *p){ printf(FORMAT，p->num，p->name，p->score［0］，p->score［1］，p->score［2］）；

printf（″＼ｎ″）； } 运行结果： 12345 Li Li 67.500000 89.000000 78.599998  有10个学生，每个学生的数据包括学号、姓名、3门课的成绩，从键盘输入10个学生数据，要求输出3门课程总平均成绩，以及最高分的学生的数据（包括学号、姓名、3门课程总成绩、平均分数）。 10.1：# include 

struct student 

{ char num[6];

char name[8];

int score[3];

float avr;

}stu[10];

 main()

{ int i,j,max=0,maxi=0,sum=0;

float average=0;

for(i=0;i<10;i++)

{ scanf(“%s%s”,stu[i].num,stu[i].name);

for(j=0;j<3;j++)

scanf(“%d”,&stu[i].score[j]);

}

 for(i=0;i<10;i++)

{ sum=0;

for(j=0;j<3;j++)

sum+=stu[i].score[j];

stu[i].avr=sum/3.0;

average+=stu[i].avr;

if(sum>max){ max=sum;maxi=i;} 

} 

average/=10;

printf(“average=%6.2fn”,average);

printf(“The highest is:%s,%s,%d,%f”，stu[maxi].num,stu[maxi].name,max,stu[maxi].avr); }

指针

例9.４ 输入ａ、b、ｃ3个整数，按大小顺序输出。#include void main（）

｛void exchange（int *q1，int *q2，int *q3）;int ａ,b,ｃ，*p1，*p2，*p3；

scanf（″%ｄ，%ｄ，%ｄ″，&ａ, &ｂ, &ｃ）；

p1＝＆ａ；p2＝＆ｂ；p3＝＆ｃ；

exchange（p1，p2，p3）；

printf（″％ｄ,％ｄ,％ｄ＼ｎ″,ａ,ｂ,ｃ）；

｝

void exchange（int *q1，int *q2，int *q3）｛ void swap（int *pt1，int *pt2）;

if（*q1＜*q2）swap（q1，q2）；

if（*q1＜*q3）swap（q1，q3）；

if（*q2＜*q3）swap（q2，q3）；

｝

void swap（int *pt1，int *pt2）

｛int temp；

temp＝*pt1；

*pt1＝*pt2；

*pt2＝temp；

score 3

｝

运行情况如下：

9,0,10↙ 10,9,0

例9.10：有一个班，３个学生，各学４门课，计算总平均分数以及第ｎ个学生的成绩。这个题目是很简单的。只是为了说明用指向数组的指针作函数参数而举的例子。用函数average求总平均成绩，用函数search找出并输出第ｉ个学生的成绩。#include void main（）

{ void average（float *p，int n）；

void search（float(*p）［4］，int n)；

float score［3］［4］={{65，67，70，60}，average（*score，12）； ／*求12个分数的平均分*／

search（score，２）；

／*求序号为２的学生的成绩*／ ｝

void average（float *ｐ，int ｎ）{ float*ｐ_ｅｎｄ；

float sum＝０，aver；

p_end＝ｐ＋ｎ－１；

for（；ｐ＜＝ｐ_ｅｎｄ；ｐ＋＋）

sum＝sum＋（*ｐ）；

aver＝sum／ｎ；

printf（″average＝％5.2ｆ＼ｎ″，aver）； ｝

void search（float(*ｐ)[4]，int ｎ）

/ * p是指向具有4个元素的一维数组的指针 */ ｛int ｉ;

printf（″the score of No.%d are：n″，n);

for（ｉ＝０；ｉ＜４；ｉ＋＋)

printf（″％5.2ｆ″，*（*（ｐ＋ｎ）＋ｉ））;｝

程序运行结果如下： average＝８２．２５

The score of No.2 are：

９０.００ ９９.００ １００.００ ９８.００

例9.11： 在上题基础上，查找有一门以上课程不及格的学生，打印出他们的全部课程的成绩。

#include void main（）

｛void search（float(*p)［4］，int n）；

float score[3][4]={{65，57，70，60}，{58，87，90，81}，{90，99，100，98}};

{80，87，90，81}，{90，99，100，98}};

search（score，３）；

｝

void search（float(*p)［4］，int ｎ）｛int ｉ，ｊ，ｆｌａｇ；

for（ｊ＝０；ｊ＜ｎ；ｊ＋＋)

｛flag＝０；

for（ｉ＝０；ｉ＜４；ｉ＋＋)

if（*（*（ｐ＋ｊ）＋ｉ）<60)flag＝１；

if（ｆｌａｇ＝＝１）

{ printf(“No.%d fails，his scores are: ＼n”，j+1);

for（ｉ＝０；ｉ＜４；ｉ＋＋）

printf（″%5.1ｆ″，*(*(p+j)+i))；

printf（″＼ｎ″）；

｝

｝

｝

程序运行结果如下：

No.1 fails, his scores are：

６５.０

５７.０

７０.０

６０.０ No.2 fails, his scores are：

５８.０ ８７.０ ９０.０ ８１.０ 例9.17：求a和b中的最大者。#include void main（）

｛int max（int，int）;int a,b,c；

scanf(″%d,%d″,&a,&b);

ｃ＝max(a,b);printf(″a=%d,b=%d,max=%dn″,a,b,c);

｝

int max(int x,int y)｛ int z;

if(x>y)ｚ=ｘ;

else

ｚ=ｙ;

return(z);

｝

例9.18：有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用指针函数来实现。

#include void main（）

｛float score[][4]={{60，70，80，90}，{56，89，67，88}，{34，78，90，66}}；

float *search（float(*pointer)[4]，int n）；

float*ｐ；

int ｉ，ｍ；

printf（″enter the number of student：″）；

scanf（″％ｄ″，＆ｍ）；

printf（″The scores of No．%d are：n″,m)； ｐ＝search（score，m）；

for（ｉ＝０；ｉ＜４；ｉ＋＋)printf（″%5.2fｔ″，*（ｐ＋ｉ））；

｝

float *search（float(*pointer)[4］，int ｎ）｛ float *pt；

pt＝*（pointer+n）；

return（pt）；

｝

运行情况如下：

enter the number of student：１↙ The scores of No.１ are：

56.00

89.00

67.00

88.00 例9.19： 对上例中的学生，找出其中有不及格课程的学生及其学生号。#include void main（）

{ float score[][4]={{60，70，80，90}，{56，89，67，88}，{34，78，90，66}}；

float search（float(*pointer)[4]);

float*ｐ；

int i,j；

for（i=0;i<3;i++）

｛ｐ＝search（score+i）；

if（p==*(score+i))

｛ printf（″No.%d scores：″,i)；

for（j=0;j<4;j++)

printf（″%5.2f″，*(p+j)）；

printf（″n″）；｝

｝

｝

float *search(float(*pointer)[4]){ int i;

float *pt;

pt=*(pointer+1);

for(i=0;i<4;i++)

if(*(*pointer+i)<60)pt=*pointer;

return(pt);

} 运行情况如下：

No.1 scores：56.00 89.00 67.00 88.00

No.2 scores：34.00 78.00 90.00 66.00 

例9.20：将若干字符串按字母顺序(由小到大)输出。#include #include void main（）

｛void sort（char *name［ ］，int n）；

void print（char *name［ ］，int n）；

char *name［ ］={“Follow me”，“BASIC”，“Great Wall″，”FORTRAN“，”Computer design“};int ｎ＝５；

sort（name，ｎ）；

print（name，ｎ）；

｝

void sort（char *name［ ］，int ｎ）｛char *temp；

int ｉ，ｊ，ｋ；

for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋)｛k＝ｉ；

for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋)

if（strcmp（name[ｋ],name[ｊ])>0）ｋ=ｊ；

if（ｋ!＝ｉ）

{ temp=name［i］;

name［i］=name［k］;

name［k］=temp;｝

｝

｝

void print（char *name［ ］，int ｎ）｛ int ｉ；

for（ｉ＝０；ｉ＜ｎ；ｉ＋＋）

printf（″%sn″，name[i]）；

} 运行结果为： BASIC Computer design FORTRAN Follow me Great Wall 作业：(提交上机报告)输入10个整数，将其中最小的数与第一个数对换，把最大的数与最后一个数对换。写3个函数：①输入10个数；②进行处理；③输出10个数。# include main()

{ void input(int number[10]);

void max_min_value(int array[10]);

void output(int array[10]);

int number[10];input(number);max_min_value(number);output(number);

} void input(int number[10])

{ int i;

for(i=0;i<=9;i++)

scanf(“%d”,&number[i]);} void max_min_value(int array[10])

{ int *max,*min,*p,*array_end;

array_end=array+10;

max=min=array;

for(p=array+1;p

if(*p>*max)max=p;

else if(*p<*min)min=p;

*p=array[0];array[0]=*min;*min=*p;

*p=array[9];array[9]=*max;*max=*p;

} void output(int array[10])

{ int *p;

for(p=array;p<=array+9;p++)

printf(“%4d”,*p)； }

数组和函数的组合

例8.12 有一个一维数组，内放10个学生成绩,写一个函数，求出平均分、最高分和最低分。#include float Max＝０，Min＝０；

／*全局变量*／ void main（）

｛float average（float array［ ］，int n）;

float ave，score[10]；

int ｉ；

for（ｉ＝０；ｉ＜１０；ｉ＋＋）

scanf（″％ｆ″，＆score［ｉ］）；

ave= average（score,10）；

printf(″max=%6.2f＼nmin=%6.2f＼n

average=%6.2f＼n″，Max，Min，ave)；

}

float average（float array［ ］，int n）

／*定义函数，形参为数组*/ ｛ int ｉ；

float aver，sum=array［０］；

Max=Min=array［０］；

for（ｉ=１；ｉ＜ｎ；ｉ＋＋）

｛if（array[i]＞Max）Max＝array[i]；

else if（array[i]

sum=sum+array［ｉ］；

｝

aver＝sum/n；

return（aver）；

｝

例8.18 有一个含若干字符的字符串,今输入一个字符,要求程序将字符串中该字符删去。用外部函数实现。file1.c（文件１）#include void main()

{ extern void enter_string(char str[]);

extern void detele_string(char str[],char ch);

extern void print_string(char str[]);

char c;

char str[80];enter_string(str);

scanf(”%c“,&c);

detele_string(str,c);

print_string(str);

} file２.c（文件２）#include void enter_string(char str[80]){

gets(str);}

file３.ｃ（文件３）

void delete_string(char str[],char ch){ int i,j;

for(i=j=0;str[i]!=';i++)

if(str[i]!=ch)

str[j++]=str[i];

str[i]=';} file４.ｃ（文件４）#include void print_string(char str[]){

printf(”%sn",str);}

运行情况如下：

ａｂｃｄｅｆｇｃ↙

(输入ｓｔｒ）

ｃ↙ 

（输入要删去的字符）ａｂｄｅｆｇ

（输出已删去指定字符的字符串）

8.1：判断m是否是素数。（用函数实现）#include main()

{ int f(int m);

int m,n;

scanf(“%d”,&m);

n=f(m);

if(n)printf(“%d is a prime numbern”,m);

else printf(“%d is not a prime numbern”,m);

}

int f(int m)

{ int i,k,p;

k=sqrt(m);

for(i=2;i<=k;i++)

if(m%i==0)break;

if(i>=k+1)p=1;

else p=0;

return p;

}

8.2：用起泡法对10个数排序。（用函数实现）

#include main()

{ void sort(int array[],int n);

int a[10],i;

for(i=0;i<10;i++)

scanf(“%d”,&a[i]);

sort(a，10);

for(i=0;i<10;i++)

printf(“%4d”,a[i]);} void sort(int array[],int n)

{ int i,j,t;

for(i=0;i

for(j=0;j<9-i;j++)

if(a[j]>a[j+1])

{ t=a[j];a[j]=a[j+1];a[j+1]=t;}

}

8.3：用选择法对10个数排序。（用函数实现）#include main()

{ void sort(int array[],int n);

int a[10],i;

for(i=0;i<10;i++)

scanf(“%d”,&a[i]);

sort(a，10);

for(i=0;i<10;i++)

printf(“%4d”,a[i]);} void sort(int array[],int n)

{ int i,j,k,t;

for(i=0;i

{ k=i;

for(j=i+1;j

if(array[j]

t=array[k];array[k]=array[i];array[i]=t;

}

6.c语言学习总结 篇六

c语言学习总结篇一：

怎么才能学好c语言呢?

1，要学习c语言的基本语言及程序结构，这时谭浩强的那本书就比较经典了。c语言学习心得。当然你不能只看书，要动手动写代码，去上机测试。因为很多时候写程序就是一个测试，你就是再牛的程序员也不能可写出没有bug的程序，所以学会找出程序中的错误很重要。这也是你以后分析他人的程序的先决条件，不可偷懒只看书，这样你是不可能学好一门计算机语言的。

2，分析他人写的程序，网上有很多实例代码，下载下来自己先看一下他们的实例是解决什么问题的，有时候很多经典的模块可以为已所用的。不过，网上下的代码中会存在很多问题，环境问题啊，编程习惯问题了，不过也好，在解决问题的过程中你会学到很多东西的，像我在分析网上下的代码时就遇到了我平时没有遇到的dos函数，masm与c语言的接合等方面的问题，学到了不少东西呢。

3，要是你再想学的深一点儿，那还得学习，及，再深就要去分析linux内核或是驱动程序了，这因人而异。但不管怎么学，一定要有个方向，有计划，这样才会事半功倍。c语言学习心得。如果你能找到你想学习方面的高手指导，或是几个人一起学的话那就更好了。

4，分析c语言函数的实现方法。这对你很好地使用函数会很有帮助的，再者很多大公司的笔试题就是让你实现c语言的数，比如:中兴的strcpy，阿里巴巴的strcmp，上海贝尔公司宣讲会上一个技术总监说，要是谁能说出printf的实现方法及返回值，当场录用。再者，c语言经过这么多年的考验，仍然很热门，可见其开发是多么经典啊，学习一下c函数实现，比学习任何书都要好。要是再有兴趣的话就分析一下c的头文件，这也是个不错的学习方面。c语言学习总结篇二：

学习c程序设计语言除了课堂讲授以外，必须保证有不少于课堂讲授学时的上机时间。因为学时所限，课程不能安排过多的统一上机实验，所以希望学生有效地利用课程上机实验的机会，尽快掌握用c语言开发程序的能力，为今后的继续学习打下一个良好的基础。为此，我们结合课堂讲授的内容和进度，安排了12次上机实验。课程上机实验的目的，不仅仅是验证教材和讲课的内容、检查自己所编的程序是否正确，课程安排的上机实验的目的可以概括为如下几个方面:

1。加深对课堂讲授内容的理解

课堂上要讲授许多关于c语言的语法规则，听起来十分枯燥无味，也不容易记住，死记硬背是不可取的。然而要使用c语言这个工具解决实际问题，又必须掌握它。通过多次上机练习，对于语法知识有了感性的认识，加深对它的理解，在理解的基础上就会自然而然地掌握c语言的语法规定。对于一些内容自己认为在课堂上听懂了，但上机实践中会发现

原来理解的偏差，这是由于大部分学生是初次接触程序设计，缺乏程序设计的实践所致。

学习c语言不能停留在学习它的语法规则，而是利用学到的知识编写c语言程序，解决实际问题。即把c语言作为工具，描述解决实际问题的步骤，由计算机帮助我们解题。只有通过上机才能检验自己是否掌握c语言、自己编写的程序是否能够正确地解题。

通过上机实验来验证自己编制的程序是否正确，恐怕是大多数同学在完成老师作业时的心态。但是在程序设计领域里这是一定要克服的传统的、错误的想法。因为在这种思想支配下，可能你会想办法去“掩盖”程序中的错误，而不是尽可能多地发现程序中存在的问题。自己编好程序上机调试运行时，可能有很多你想不到的情况发生，通过解决这些问题，可以逐步提高自己对c语言的理解和程序开发能力。

2。熟悉程序开发环境、学习计算机系统的操作方法

一个c语言程序从编辑、编译、连接到运行，都要在一定的外部操作环境下才能进行。所谓“环境”就是所用的计算机系统硬件、软件条件，只有学会使用这些环境，才能进行程序开发工作。通过上机实验，熟练地掌握c语言开发环境，为以后真正编写计算机程序解决实际问题打下基础。同时，在今后遇到其它开发环境时就会触类旁通，很快掌握新系统的使用。

3。学习上机调试程序

完成程序的编写，决不意味着万事大吉。你认为万无一失的程序，实际上机运行时可能不断出现麻烦。如编译程序检测出一大堆错误。有时程序本身不存在语法错误，也能够顺利运行，但是运行结果显然是错误的。开发环境所提供的编译系统无法发现这种程序逻辑错误，只能靠自己的上机经验分析判断错误所在。程序的调试是一个技巧性很强的工作，对于初学者来说，尽快掌握程序调试方法是非常重要的。有时候一个消耗你几个小时时间的小小错误，调试高手一眼就看出错误所在。

7.C语言学习总结 篇七

暑假即将来临，很开心，但也意味着C语言的学习即将到了尾声。谈及C语言，我想凡是学过它的朋友都有这样一种感觉，那就是“让我欢喜让我忧。”欢喜的是，C语言功能非常强大、应用广泛，一旦掌握了后，你就可以理直气壮地对他人说“我是电脑高手！”，而且以后若是再自学其他语言就显得轻而易举了。忧虑的是，C语言犹如“少林武功”一般博大精深，太难学了。

其实怎么说呢，学习它的时间说长不长，说短也不短了。可是对于它，我也只能说还是处于一知半解的状态下。说不懂吧，你让我拿着书自己也能写出程序来，说不懂呢，就是相对于难一点的程序我就不行了。

不过就算如此也还是有不少收获的。首先，老师让我们时常的敲程序，一开始不明白，后来慢慢发现敲程序也许是最笨的方法但也是进步最快的方法。敲程序的过程就是积累经验的时候，而自己写程序才是真正把所学为所用的时候，可以说只有你做一个大点的程序写出来才能真正是说明你学到了东西，你会用所学的东西，要不然就算你学的再多，不会用也没用啊。其次，在看它敲它的过程中，也从中了解了它的规则是什么、有什么用、怎么实现等，这样自己编起程序来也更得心应手了。最后，也养成了良好的编程习惯。例如编写程序时用缩进的方式、写注释、程序写到一定的阶段时要做一下测试等。这些工作可以帮我们在调试程序时有很大的帮助。程序代码实现后，错误是难免的，所以也要锻炼自己的调试查错能力，而良好的编程习惯

可以使我们在调试时减小工作量和提高调试效率，也有助于形成自己的编程风格。

说了很多学到的，当然也有欠缺的地方。比如，书，我很少看，只有敲程序，或者编程序的时候我才会看。敲程序呢，坚持的时间也不是很持久，只有想的时候和上课的时候才回敲。

8.大学怎么学好c语言有哪些方法 篇八

这里介绍几个学习C语言必备的装置和书籍：

A)开发环境

例如turbo C 2.0,这个曾经占据了DOS时代开发程序的大半个江山。但是现在windows时代，用turbo C有感觉不方面，编辑程序起来很吃力，并且拖放，更没有函数变量自动感应功能，查询参考资料也不方便。建议使用Visual C++,这个平台虽然体积大，但是一旦安装好了，用起来很方便。

B)一本学习教程

现在C语言教材多如牛毛，推荐大家使用《C语言程序设计》第二版。此书很适合初学者，并且内容也很精到。

C)利用辅助学习软件

毕竟现在是Windows时代了，学习软件多如牛毛，这里向大家推荐一个“集成学习环境(C语言)”，里边的知识点总结和例程讲解都非常好，有好几千题的题库测试环境，包括一个windows下的trubo C，初学者甚至不用装其它的编译器，就可以练习编程了。还有一个“C语言学习系统”软件，不过感觉只是一个题库系统，如果你觉得题做的不够，不妨也可以试试。

二、葵花宝典

学习计算机语言最好的方法是什么?答曰：读程序。

没错，读程序是学习C语言入门最快，也是最好的方法。我们大家都应该有个体验——在最初学习windows系统操作或Microsoft words如果操作的过程中，刚开始总是正儿八经地买来教材，结果读来读去却云里雾里，而当我们将教材丢在一边，拿起鼠标反复地试，几个小时就搞定。包括学习J#,C#等其他语言，在今天的Windows时代，也不再提倡抱着书本逐行啃，而是学习它们的例程。

当然，对于没有学过任何计算机语言的初学者，多少要先阅读教程，认真体会所有概念，然后不放过这一章中提到的所有例程，仔细研读，直到每一行都理解了，再找几个编程题目，最好是和例程类似的或一样的，自己试图写出这段已经读懂的程序。如果写不出来，回过头来再继续研究例程，想想自己为什么写不出来，然后再去写这段程序，反反复复，直到你手到擒来为止。

三、登峰造极

写程序的最高境界其实就是掌握各种解决问题的手段(数据结构)和解决问题的方法(算法)。

是不是写出底层程序就是程序设计高手呢?非也，写底层程序，无非是掌握了硬件的结构，况且硬件和硬件还不一样，要给一个芯片写驱动程序，无非就是掌握这块芯片的各种寄存器及其组合，然后写值读值，仅此而已。这不过是熟悉一些I/O函数罢了。那么怎样才算精通程序设计呢?怎样才能精通程序设计呢?举个例子：

9.C语言二级上机考试要点总结 篇九

2007年9月，教育部考试中心对现有的全国计算机等级考试大纲进行了改革，二级C语言上机考试时间由60分钟增加到了90分钟，编程环境由以前的TC2.0改为VC++6.0。[2]本文根据对近几年来二级C语言上机考试中的程序设计题进行归类总结，提出相应的策略，并对考生应对2007新大纲以后的C语言上机环境给出一些建议。2 对以往考试的分析

历年的全国计算机等级考试中二级C语言上机考试程序设计题目全部出自于由南开大学出版社编写南开100题，每次考试教育部考试中心会对题库做相应的改动，增加一些新的题型或题目，考试中，考生随机抽取一套进行测试。笔者对2005年4月至2007年9月2004版新大纲以后的6次考试中的程序设计题目进行了总结，将这些题目一共分成了6大类，对每种类型的题目进行了分析。2.1 对一维数组和字符串的操作

该类型的题目在以往的机试中所占比例最大，为40%，考生应对该知识点做全面的复习和掌握。一维数组可以分为数值型和字符型，其中数值型数组的数据类型为整型和实型，字符型数组的数据类型为字符型，我们通常会把字符型数组叫做字符串，但是应该注意字符型数组与字符串之间是存在区别的，也就是’’结束标志问题。在复习该部分的时候，考生应该掌握以下两个问题：（1）对一维数组的操作

对一维数组进行操作的时候，不可避免的要访问相关的数组元素，在C语言中访问数组元素一般采取单层循环的方法进行遍历，假设数组长度为n，数组下标是在0到(n-1)之间的，考生应该牢固掌握在一维数组中求最大值、最小值，移动元素，查找特定值，存储数组元素的方法。

（2）对字符串的操作

该类问题是每次考试的重点和难点，特别是将字符串同指针结合起来以后，难度就更大了。考生在解决此类问题是应特别注意字符串的结束标志’’，它不仅仅用来作为字符串的结束标志，而且在对字符串进行操作的时候，它也是循环的结束标志。考生在复习该部分的时候，应该注意这样的几个基本问题：大小字母转换、奇偶数判别、删除或添加指定的字符和字符的移动。此外，考生应该牢固掌握指针的特性及字符串操作函数的使用和实现方法，特别是字符串连接函数与求子串函数，在以往的考试中多次要求考生自己编写，考生应对该知识点做重点掌握。2.2 数值计算

该类型的题目在历年的机试中占22%，考查的机率也非常高。该类题目一般给定一个数列计算公式，然后要求考生编写一个函数类实现求数列的前n项的值、累加和或者积。在解决该类的问题，首先要找到给定数列的变化规律，然后根据其变化规律来编写一个单层或者双层的循环来求其相应的值。在编写程序的过程中，往往还会用到一些数学函数，如：sqrt()、fabs()、pow()等，考生应该牢固掌握math.h中的一些常用数学函数的功能和使用方法。另外，还应该注意数据类型之间的区别，特别是float和int类型，不同的数据类型产生的运算结果也是不一样的。2.3 对结构体的操作

该部分对非计算机专业的学生来说是一个难点，因为结构体在《数据结构》这门课程中应用最为广泛，但考生忽视对该知识点的复习，但在以往的机试中，有17%的题目是属于该类型。考生在复习这部分的时候，首先应注意结构体成员的两种不同的引用方法：结构体变量和指向结构体的指针，也就是结构体成员运算符’.’和指向运算符’->’，在编程的过程中，往往会涉及到结构体数组，其实这类数组除了数据类型是结构体以外，其它的特性和普通数组是一样的，结构体除了定义、赋值和初始化以外，它的其它操作和普通变量也是一样的，包括在结构体数组（记录）中进行查找、删除、求最大最小值等操作，我们应该用对待普通变量的方法来解决结构体的问题，这样的话，难度就可以大幅度的降低。2.4 对二维数组的操作

该类问题在历年的机试中占16%，考生应对二维数组的数组元素的遍历方法、存储方式、矩阵转换等问题做重点掌握。在C语言中，访问二维数组的数组元素一般采用双层循环的方法实现，因为二维数组具有两个下标：行下标与列下标；二维数组可以按行或者按列转化成一维数组进行存储；对二维数组进行行列转换的时候，要将行下标和列下标进行互换。考生还应该掌握上三角矩阵、下三角矩阵的特性，在考试中，该知识点也有所涉及。2.5 数制转换

该部分在以往的机试中占11%，包括两类问题：一是整数合并，二是类型转换。在复习该部分时，考生应该注意C语言中int型、long型、float型和double型数据所占的存储空间的大小和精度，注意’%’（模）运算和’/’（除法）运算的特点，特别应该灵活的使用模运算与除法运算求数据相应位数上的数值。掌握强制类型转换的方法以及按规定的位数保留小数的方法。2.6 素数

该部分在历年的机试中占6%，考生应该牢固掌握素数的基本概念和判断素数的方法。特别需要考生注意的是整数1不是素数，所以在判断素数的时候，应该从2开始，到(n-1)结束，能够除尽的不是素数，不能除尽的是素数。判断素数问题是C语言中的一个基本算法，不仅会在程序设计中会考到，而且往往在程序填空和程序改错中也会有所涉及，因此，考生应对该知识点认真复习。3 程序设计中应注意的问题 3.1 熟悉编程环境

根据2007年9月教育部考试中心颁布的新大纲，二级C语言的编程环境由TC2.0改为VC++6.0，考生应该熟练掌握VC++6.0的使用方法，虽然VC支持鼠标操作，但是考生还是应该掌握几个常用快捷方式来提高编程效率。特别要注意在对程序进行改动以后要保存，要进行编译连接生成可执行（.exe）文件。3.2 养成良好的程序设计风格

二级C语言机试中的程序设计题，一般来说程序都比较简短，源代码一般不超过5行，在题目指定的函数内编写程序。考生在答题的时候尽量采用易于理解而且比较简单的代码来解决问题，注意不要改动函数的参数，语句的界符“{}”也应该具有层次性的缩进，必要时，使用一定的注释来帮助自己理解程序。3.3 谨慎使用指针

指针是C语言的精华，也是机试考查的重点内容，指针的使用非常灵活，在使用的指针的时候一定要注意对其进行初始化，所谓初始化也就是给指针一个初值，没有初值的指针是很危险的，除了一定得不到正确答案外，如果指针越界，容易引起死机。如果死循环带来的死机是“假死”，大部分可以用“Ctrl+Break”来恢复，但指针越界引起的死机却是真死，请考生一定要牢记。[3] 3.4 熟练掌握循环结构

循环结构的程序是程序设计中涉及最多的知识点，根据以上的分析，我们可以看出几乎每一类题目都会涉及到使用循环来解决问题，因此考生应该掌握循环结构的特征和使用方法，以达到能够熟练使用的目标。应该引起注意的是，在编制循环结构程序的时候考生应该尽量使用“for”循环和“while”循环，避免使用“do……while”循环和“goto”语句，因为“for”循环和“while”编写出来的循环程序易于理解，不容易出错。3.5 沉着应战，认真细心

二级C语言上机考试时间有限，虽然从以前的60分钟改为了90分钟，但是相对于其它语种的上机考试来说，二级C语言的上机时间还是非常紧迫的。考生在答题的过程中应该保持一个良好的心态和平静的心情，遇到问题的时候不能慌乱，最好能够在机试时带一张草稿纸和一支笔，在编程之前先画出程序的流程图来明确解题思路。在遇到程序错误时一定要根据错误代码检查相应位置，检查的过程中应该认真仔细，确保能够解决问题。4 结束语

10.c语言中static用法总结 篇十

C程序一直由下列部分组成：

正文段——CPU执行的机器指令部分；一个程序只有一个副本；只读，防止程序由于意外事故而修改自身指令；

初始化数据段（数据段）——在程序中所有赋了初值的全局变量，存放在这里，

非初始化数据段（bss段）——在程序中没有初始化的全局变量；内核将此段初始化为0。

栈——增长方向：自顶向下增长；自动变量以及每次函数调用时所需要保存的信息（返回地址；环境信息）。

堆——动态存储分。

|-----------|

|          |

|-----------|

|    栈   |

|-----------|

|    |     |

|   |/   |

|          |

|          |

|   /|   |

|    |     |

|-----------|

|    堆   |

|-----------|

| 未初始化|

|-----------|

| 初始化 |

|-----------|

| 正文段 |

|-----------|

二、 面向过程程序设计中的static

1. 全局静态变量

在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。

内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）

初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

看下面关于作用域的程序：

查看原始代码

//teststatic1.c

voiddisplay;

externintn;

intmain()

{

n=20;

printf(“%dn”,n);

display();

return0;

}

查看原始代码

//teststatic2.c

staticintn;//定义全局静态变量，自动初始化为0，仅在本文件中可见

voiddisplay()

{

n++;

printf(“%dn”,n);

}

文件分别编译通过，但link的时候teststatic1.c中的变量n找不到定义，产生错误。

定义全局静态变量的好处：

<1>不会被其他文件所访问，修改

<2>其他文件中可以使用相同名字的变量，不会发生冲突。

2. 局部静态变量

在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。

内存中的位置：静态存储区

初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束，

注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。

当static用来修饰全局变量的时候，它就改变了全局变量的作用域（在声明他的文件之外是不可见的），但是没有改变它的存放位置，还是在静态存储区中。

3. 静态函数

在函数的返回类型前加上关键字static，函数就被定义成为静态函数。

函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。

例如：

查看原始代码

//teststatic1.c

voiddisplay();

staticvoidstaticdis();

intmain()

{

display();

staticdis();

renturn0;

}

查看原始代码

//teststatic2.c

voiddisplay()

{

staticdis();

printf(“display() has been calledn”);

}

staticvoidstaticdis()

{

printf(“staticDis() has been calledn”);

}

文件分别编译通过，但是连接的时候找不到函数staticdis()的定义，产生错误。

定义静态函数的好处：

<1> 其他文件中可以定义相同名字的函数，不会发生冲突

<2> 静态函数不能被其他文件所用。

存储说明符auto，register，extern，static，对应两种存储期：自动存储期和静态存储期。

auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。

关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期（static storage duration），或静态范围（static extent）。虽然他的值在函数调用之间保持有效，但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。

由于static变量的以上特性，可实现一些特定功能。

1． 统计次数功能

声明函数的一个局部变量，并设为static类型，作为一个计数器，这样函数每次被调用的时候就可以进行计数。这是统计函数被调用次数的最好的办法，因为这个变量是和函数息息相关的，而函数可能在多个不同的地方被调用，所以从调用者的角度来统计比较困难。代码如下：

查看原始代码

voidcount();

intmain()

{

inti;

for(i=1; i<=3; i++)

count();

return0;

}

voidcount()

{

staticnum=0;

num++;

printf(“ I have been called %d”,num,“timesn”);

}

输出结果为：

I have been called 1 times.

C语言程序可以看成由一系列外部对象构成，这些外部对象可能是变量或函数。而内部变量是指定义在函数内部的函数参数及变量。外部变量定义在函数之外，因此可以在许多函数中使用。由于C语言不允许在一个函数中定义其它函数，因此函数本身只能是“外部的”。

由于C语言代码是以文件为单位来组织的，在一个源程序所有源文件中，一个外部变量或函数只能在某个文件中定义一次，而其它文件可以通过extern声明来访问它（定义外部变量或函数的源文件中也可以包含对该外部变量的extern声明）。

11.c语言数组方法总结 篇十一

1.输入元素的值：

inti,a [10];

for(i = 0;i < 9;i ++);

a[i] = i;

(1)正序排列：(2)倒序排列：

for(i =0;i < 10;i ++)for(i = 9;i >= 0;i--)printf(“%d”, a[i]);printf(“%d”, a[i]);

2.初始化元素的值：

（1）在定义时，将数组元素一次放在一对花括号里;

eg: int a[10]={1,2,3,4,5,6,7,8,9,0};

(2)可以只给一部分元素赋值:

eg: int a[10]={1,3};

(3)使数组全部元素为0：

eg: int a[10]={0,0,0,0,0,0,0,0,0,0};或者 int a[10]={0};

(4)在对全部元素赋初值的时候，由于元素数已经确定，因此，可以不指定数组长度。（注：数组长度与提供初值个数不相同时，则长度不可以省略。）

3.巧妙地将两个元素列在一个循环中输出：（用for循环处理fobonacci数列）； eg：int f[20]={1,1};

for(i=2;i<20;i++)

f[i]=f[i-1]+f[i-2];

4． 数列Fobonacci数列核心：

int f[20]={1,1};

for(i=2;i<20;i++)

f[i]=f[i-1]+f[i-2];

5.换行操作：

for(i=0;i<=20;i++)/*当然也可以在for循环中处理，直接将{if(i%5= =0)printf(“n”);if(i%5= =0)printf(“n”);插入换行*/Printf(“%12ld”,f[i]);

}

6.起泡法：

int a[10];

for(j=0;j<9;j++)/*进行n-1趟比较*/

for(i=0;i<9-j;i++)/*在j趟比较中，比较n-1次*/

if(a[i]>a[i+i])/*由小到大排列，if(a[i]

7.初始化二维数组：

 分行给二维数组赋初值；

 将所有的元素都写在一个花括号里；

 对部分元素赋值：

1)int a[3][3]={{3},{5},{9}};只讲0列元素赋值

2)int a[3][3]={{1}, {0,6},{0,0,11}};对部分元素赋值，对非0元素少使用方便

3)int a[3][3]={{1}, {5,6}};只对几行元素赋值

4)int a[3][3]={{1}, {},{9}};对第二行元素赋值

 对全部元素赋值可以省略一维长度：

 对部分元素赋初值，在省略一位长度时，应分行赋值：

8.二维数组的输入输出：

 输入：直接定义

 输出：

for(i=0;i<=2;i++)

{for(j=0;j<=1;j++)

printf(“%5d”,b[i][j]);

printf(“n”);

}

9.二维数组的行列转换：

b[j][i]=a[i][j];

10.数组中求最大值并输出行列号：

Eg：inti,row=0,colum=0,max;

inta[3][4]={1,2,3,4,5,6，7,8,9,10,11,12};

max=a[0][0];

for(i=0;i<=2;i++)

for(j=0;j<=3;j++)

if(a[i][j]>max)

{max=a[i][j];

row=i;

colum=j;}

11.字符数组的初始化方法：

 逐个字符初始化：

eg：char c[10]={„I‟, „‟, „a‟, „m‟, „‟, „h‟, „a‟, „p‟, „p‟, „y‟};

1)在定义字符数组时，不初始化，则数组中的各元素的之不可预料；

2)如果花括号中提供的初值个数（即字符个数）大于数组的长度，则按语法错误

处理；

3)如果花括号中提供的初值个数（即字符个数）小于数组的长度，其余元素自动

定为空字符即（„‟）;

 如果提供的初值个数与数组长度相同，则在定义时可以省略数组长度；  也可以定义一个二维数组：

eg:char diamond[5][5]={{},{},{},{},{}}; 用字符串常量，使字符数组初始化：

eg： char c[ ]={“I am happy”};或char c[ ]= “I am happy”;

12.字符数组的输出：

一维：二维：

for(i=0;i<=11;i++)for(i=0;i<=11;i++)

printf(“%c”,c[i]);for(i=0;i<5;i++)

printf(“n”);printf(“%c”,diamond[i][j]);

13.字符数组输出最大值：

eg：if(strcmp(string,str[1]>0)

strcpy(string,str[0]>0);

else

strcpy(string,str[1]);

if(strcmp(str[2],string>0)

strcpy(string,str[2]);