引子：

#include <stdio.h> /*预处理*/

#include <stdio.h>

Void sort(char *names[],int n); /*函数声明*/

Void prt(char *names[],int n);

Void main(void)

{

Char *names[]={“CHINA”,”AMERICA”,”AUSTRALIA”,”FRANCE”,”GERMAN”}; Int n=5; /*申请变量，变量类型，运算*/ Printf(“原顺序国家名：\n”);

Prt(names,n); /*函数的引用*/ Sort(names,n);

Printf(“排序后的国家名:\n”);

Prt(names,n);

}

Void sort(char *names[],int n) /*函数体*/

{

Char *t; /*指针*/

Inti,j,k;

For(i=0;i<n-1;i++) /*for循环结构*/

{ K=I;

For(j=i+1;j<n;j++)

{

If(strcmp(names[k],names[j])>0) k=j;

If(k!=i)

{

t=names[i];

names[i]=names[k];

names[k]=t;

}

}

}

Void prt(char*names[],int n)

{

Inti;

For(i=0;i<n;i++)

Print(“%s\n”,names[i]);

}

C程综述：程序均有程序主体，编译预处理，注释三部分。后两者，为模块工具与可选择添加的辅助注解，程序主体为核心，主要为函数来体现功能。函数，变量，通过三种运算三种结构根据算法形成功能模块，实现预期。

基础篇

标识符：C程中有一系列表示类型名称函数名称等程序内部特定名称的字母组合，称之为关键字，这些不可更改不可移作他用。用户规定的一切变量或函数名等，不得与之冲突。

（C 程识别大小写）

标识符规则：

第一个字符必为字母或下划线，内部无特殊字符（除字母数字下划线）； 不与关键字冲突；

C程区分大小写。

数据类型：基本类型：整型int，字符型 char，实型double/float，空类型 void； 构造类型：数组[]，结构体struct，共用体union，枚举型enum； 指针类型：* ；

基本类型:

int(4)：常量：八进制以0开头（均小于8），十六进制以0X，0x开头（0~9，a~f） 允许后缀字母，L：长整型；U：无符号整型.

变量：short int(2)短整型，long int(2)长整型，unsigned/signed无/有符号整型前缀；整型变量以补码（数据绝对值二进制原码取反加一）形式存在于内存，有界，有溢出，溢出时从最小起循环。

Float：常量：浮点数，指数形式：E： 123e2=123x10^2.

可后缀f：单精度，L：长双精度 E前必有数字，E后必为整数 变量：float(4)：单精度，double(8)：双精度，long double(10)长双精度 Char：常量：单引号，char(1) 以ASCII码存储，与整型通用。变量同。

字符串：引号，末尾\0结束，结束字符算在存储空间内。（’a’ 1字节，”a”2字节） 符号常量：#define定义，

运算符与表达式：

算术运算：+、-、*、/、% /左右有任一实型，结果为实型；%结果符号以左数为主。 ++、-- 自增自减，a++/++a 在前，先参与运算，再a=a+1赋值，在后相反。 关系运算：<><= >= == != 判断真假，真为1，假为0；

逻辑运算：&& || ！ 0为假，非0为真。

赋值运算：= 变量=表达式可嵌套，=左一定为变量。

+= -= /= *= %= <<= >>= &= ^= |=

逗号运算： , 优先级最低。表达式依次计算，表达式值为最后一个表达式的值。 表达式中有赋值运算，则刷新变量值，否则变量计算后不变。

条件运算：？： e1?e2:e3 e1为真进行e2否则进行e3.

长度运算：sizeof() 括号内可为表达式，对应求出表达式结果类型的占用字节数。 类型转换：type() 由低类型转至高类型，字节逐步增多。强制转换，eg:(double)a Char、short-->int-->unsigned-->long-->double<--float

基本函数：

输出与输入函数：

字符数据输出与输入函数：getchar() 由键盘输入一个字符，连续出现此函数，多次输入对应数目的字符以回车结束；putchar() 括号内可为字符或整型数，字符用’’隔开（包括换行符等）。

格式输出与输入函数：格式：%±m.nld + - 右对齐、左对齐；m宽度；n小数位；l 长整型；d 十进制输出。（%f 浮点%c 字符%s 字符串%e指数形式输出实数等）

printf(“格式”,变量) 格式匹配，格式多于变量输出不定值，少于，多变量不予输出。变量有表达式，从右向左计算后输出。

scanf(“格式”,变量地址&取得) 格式匹配，变量分隔符由格式定，默认空格。无精度设定。.%c下输入无分隔符则空格默认为输入字符非分隔符.%ld长整型,%hd短整型,%md制定宽度,%*d输入值不赋给变量.

基本结构：

表达式语句：eg a=i+2；

复合语句：{ a=t；t=b；b=a；}

控制语句：控制分支结构、循环结构语句；控制流程转移语句.

函数调用语句：printf(“the world is beautifull”);

空语句。

顺序结构：依次执行；

分支结构：

if（if-else） if()内判定为真（表达式值非0）执行e1，否则执行else下e2.

if-if else 多分支结构，多种条件约束。最终只执行一条指令,不重叠条件.

if下由{}括起为一个语句，（）后无；.

if嵌套,对应括号缩进.

switch: 常量表达式(整型或字符型常量)均为平行并列.只判定一次.指令执行结束有break跳出,否则继续执行下个指令跳过判断,直至break.允许case标号重叠,共用语句组.字符与整型条件并存不可有冲突(‘A’ 97).default 为可选分支.

循环结构:

while()内表达式为真执行循环，复合指令用{}括起.后无；.

do-while 为真执行循环,while后有;.

for(e1;e2;e3;) E; 计算e1,计算e2并判断,为真进行循环体,计算e3,返回.

e1e2可用逗号表达式对多个变量赋初值与改动.for可省略,已赋初值,省略e1;省略e2或均省略会造成死循环;省略e1e3则等同于while语句,需先赋初值.

转移语句: break 跳出循环.用于switch 或循环体.

continue 跳过此次循环,进行下一次循环.

goto跳转.

return 返回值.

进阶篇

数组:

分类:数值数组、字符数组、指针数组、结构数组；一维数组、多维数组；

char a[] 类型、数组名、元素。数组名不与变量名冲突，元素从下标0开始编排。不允许定义动态数组，数组大小必须确定，数组大小()内可为表达式。x[2+3]

初始化：{ }括起所有元素，依次赋值；对于元素数目已知，可不确定数组大小。二维数组，初始化时，可按行分段赋初值、数组排列按行按列赋值、给部分数组元素赋值、省略第一维长度赋初值（）。

数组赋值：只能逐一赋值，不允许数组名进行整体输入输出。

数组应用：数组名，一维数组，数组名为数组首地址；二维数组，数组名为数组列首地址，每列第一元素为数组行元素首地址。当输出输入改动数组元素时，依次逐个进行，用for语句实现。

字符数组：赋值：逐个赋值，字符’’隔开；直接赋值，{ }隔开。数组长度应包括\0. 应用：scanf/printf不可输入空格（视为结束标识），数组名为首地址，不用&.

puts/gets gets每次只处理一个字符串；puts 可输出多个。以回车结束。 函数：

定义声明函数体函数头

函数定义：存储类型，函数类型（返回值类型）、函数名，形式参数表。后无；。 函数声明：同上，形参表省略变量，只留参数类型。后有；。

函数调用：传值，传地址（数组名，指针）。无参数函数调用时，（）不省略。 函数返回值：返回给主调函数。void 无返回值

形参改变时实参不变，单向传递形参用完即释放内存。返回值一定与函数相同类型，否则强制转换。

引用：值传递：a[i] 单向。

地址传递：a[] a[2] a[][3] 双向。

函数可互相嵌套调用不可嵌套定义，可递归调用。

变量作用域与存储类型：

局部变量：即局限于定义它的函数或复合语句；

全局变量：定义位置直到源程序结束。

定义类型：自动类型auto 作用域和生存期只局限于定义它的函数与复合语句。 寄存器类型register 直接存储于寄存器，提高执行速度。

静态类型static 有局限，定义值不变等待继续调用。生存期为整个程序。分为全局，局部。 外部类型 extern 定义在所有函数之外的全局变量。

内外部函数，static extern

编译预处理：

宏定义： #define 标识符字符串

宏定义允许嵌套，不占用执行时间，编译时完成。可用#undef终止宏定义域。

带参宏定义：实参为表达式，注意括号的应用；宏名与形参表之间不能有空格；区别函数。 条件编译： #if 条件 #ifdef宏名 #ifnef宏名

e1 e1e1

#else #else #else

e2 e2e2

#endif #endif #endif

条件成立，编译1 宏名已定义编译1 未经定义，编译1。

文件包含： #include “part1.h”

指针：

指针类型用被指向变量类型，但只占用4字节地址（存放地址）。

初始化：int *p=&a / int *p ；p=&a；

p可赋为空指针，p=NULL不等同野指针：void *p1

*p=a p=&a *(&a)=a &(*p)=a

通过改变地址，改变量的值：t=*p1；*p1=*p2；*p2=t；

++ -- 自加自减，移动单元数，非移动字节。关系运算极为高低端比较，==指向同一存储单元，/0 指向NULL.

p+1!= p++ 前者P值不变，仍指向变量；后者P增加了1个单元，指向了下一变量。 指针与数组：数组名为首地址常量，不可进行加减运算，只有形参数组名是指针变量，可进行加减，实现通过地址对于变量的操作。

一维a+i=&a[i] *(a+i)=a[i] = p+i=&p[i] *(p+i)=p[i]/ p+=i

a[i]-->*(a+i) == *(p+i)<--p[i] 当p移动后，需回复原位才可指向原变量。

二维首地址a

eg a[3][3] a-->a[0] - - - - a[0] a[1] a[2]

a[0] - - - - a[0][0] a[0][1] a[0][2] a为首地址，运算为行首地址变 a[1] - - - - a[1][0] a[1][1] a[1][2] 化；a+i为列首地址，运算引起 a[2] - - - - a[2][0] a[2][1] a[2][2] 同行列元素变化。 行数组首地址

a+i=&a[i] - - - - - *(a+i)=a[i]=&a[i][0] - - - - - a[i][0]=*a[i]=**(a+i)

*(a+i)+1=a[i]+1=&a[i][1] - - - - - a[i][1]=*(a[i]+1)=*(*(a+i)+1)

a[i][j] =*(*(a+i)+j)=*(a[i]+j)=(*(a+i))[j]

a[i][j]=*(a[0]+n*i+j)=*(*a+n*i+j) 对于一个四列数组：a为100，a+1为116，*a+1为104 p[i][j] =*(*(p+i)+j)=*(p[i]+j)=(*(p+i))[j]

指针数组：int (*p)[10]

a+i ---> *(a+i) ---->

&a[i]----> a[i] ----> a[i][0]

&a[i][0] ---->

指针与字符串：char *s=”hello world ”“”内为地址，只在初始化成立。

结构体：

定义：成员项-->域域后有；。

struct+ （类型名）变量名定义类型，不分配存储单元（内部总和），定义变量才申请。 初始化一一对应，引用赋值输入输出均逐一进行，egstudent.score[j]

结构体数组student[i].score[j]

空白符用getchar() 处理。

结构体指针p->num / (*p).num指向成员类型-->基类型、指向指针变量-->结构体 共用体：

union+类型名+{ }+变量名存储单元由最大的变量定。

引用：x.ax.bx.c一次赋值，则只有最后值为已存值，其余均为此值。

枚举类型：

枚举赋值：所赋值不越界，不胡乱添加对象。

用户定义类型：

typedef类型名标识符定义新类型。

第二篇：C语言总结

C六月，奋战CC语言，大家一起加油啦~~~~~~~~~~~！！

总体上必须清楚的:

1)程序结构是三种: , 三个循环结构), 和 switch)

2)读程序都要从main()入口, 然后从最上面顺序往下读(碰到循环做循环,碰到选择做选择)。

3)计算机的数据在电脑中保存是以二进制的形式. 数据存放的位置就是他的地址.

4)bit是位是指为0 或者1。 byte 是指字节, 一个字节 = 八个位.

5)一定要记住二进制如何划成十进制。

概念常考到的：

１、编译预处理不是C语言的一部分，不再运行时间。C语言编译的程序称为源程序，它以ASCII数值存放在文本文件中。

２、每个C语言程序中main函数是有且只有一个。

３、在函数中不可以再定义函数。

４、算法的是一定要有输出的，他可以没有输入。

５、break可用于循环结构和switch语句。

６、逗号运算符的级别最低。

第一章

1）合法的用户标识符考查：

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

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

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

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

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

考试口诀：e前e后必有数，e后必为整数。.

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

'1' 是字符占一个字节，"1"是字符串占两个字节(含有一个结束符号)。

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

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

考试时候一般会说，在16位编译系统，或者是32位系统。碰到这种情况，不要去管，一样做题。掌握整型一般是两个字节, 字符型是一个字节，双精度一般是4个字节就可以了。

5）转义字符的考查：

在程序中int a = 0x6d，是把一个十六进制的数给变量a 注意这里的0x必须存在。 在程序中int a = 06d, 是一个八进制的形式。

在转义字符中，’\x6d’才是合法的，0不能写，并且x是小写。

‘\141’是合法的， 0是不能写的。

‘\108’是非法的，因为不可以出现8。

6）算术运算符号的优先级别：

同级别的有的是从左到右，有的是从右到左。

7）强制类型转换：

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

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

8）表达式的考查： 是表达式就一定有数值。

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

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

运行的机理：++a 是先把变量的数值加上1，然后把得到的数值放到变量a中，然后再用这 个++a表达式的数值为6，而a++是先用该表达式的数值为5，然后再把a的数值加上1为6， 再放到变量a中。进行了++a和a++后在下面的程序中再用到a的话都是变量a中的6了。 考试口诀：++在前先加后用，++在后先用后加。

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

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

9）位运算的考查：

会有一到二题考试题目。

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

例1： char a = 6, b;

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

例3： 在没有舍去数据的时候，<<左移一位表示乘以2；>>右移一位表示除以2。 10）018的数值是非法的，八进制是没有8的，逢8进1。

11）%符号两边要求是整数。不是整数就错了。

12) 三种取整丢小数的情况：

１、int a =1.6；

２、(int)a；

３、

第二章

1）printf函数的格式考查：

%d对应整型；%c对应字符；%f对应单精度等等。宽度的，左对齐等修饰。

%ld对应 long int；%lf 对应double。

2）scanf函数的格式考察：

注意该函数的第二个部分是&a这样的地址，不是a；

Scanf(“%d%d%*d%d”,&a,&b,&c); 跳过输入的第三个数据。

3）putchar ,getchar函数的考查：

char a = getchar() 是没有参数的，从键盘得到你输入的一个字符给变量a。

putchar(‘y’)把字符y输出到屏幕中。

4）如何实现两个变量x ，y中数值的互换（要求背下来）

不可以把 x=y ,y=x; 要用中间变量 t=x；x=y；y=t。

5）如何实现保留三位小数，第四位四舍五入的程序，（要求背下来）

这个有推广的意义，注意 x = （int）x 这样是把小数部分去掉。

第三章

特别要注意：c语言中是用非0表示逻辑真的，用0表示逻辑假的。

1）关系表达式：

表达式的数值只能为1（表示为真），或0（表示假）

当关系的表达是为真的时候得到1。如 9>8这个是真的，所以表达式的数值就是1；

2）逻辑表达式：

只能为1（表示为真），或0（表示假）

a) 共有&& || ！三种逻辑运算符号。

b) ！>&&>|| 优先的级别。

c) 注意短路现象。考试比较喜欢考到。

d) 要表示 x 是比0大，比10小的方法。0<x<10是不可以的（一定记住）。是先计算0<x 得到的结果为1或则0；再用0，或1与10比较得到的总是真（为1）。所以一定要用(0<x)&&(x<10)表示比0大比10小。

3）ｉf 语句

else 是与最接近的if且没有else的相组合的。

4）条件表达式：

表达式1 ？表达式2 ：表达式3

注意是当非0时候是表达式2的数值，当为0是就是表达式2的数值。

考试口诀：真前假后。

5）switch语句：

a）一定要注意有break 和没有break的差别，书上（34页）的两个例子，没有break时候，只要有一个case匹配了，剩下的都要执行，有break则是直接跳出了swiche语句。 b）switch只可以和break一起用，不可以和continue用。

第四章

1）三种循环结构：

a）for（）； while(); do- while()三种。

b）for循环当中必须是两个分号，千万不要忘记。

c）写程序的时候一定要注意，循环一定要有结束的条件，否则成了死循环。

d) do-while()循环的最后一个while();的分号一定不能够丢。（当心上机改错）

2) break 和 continue的差别

记忆方法：

break：是打破的意思，（破了整个循环）所以看见break就退出真个一层循环。

continue：是继续的意思，（继续循环运算），但是要结束本次循环，就是循环体内剩下的语句不再执行，跳到循环开始，然后判断循环条件，进行新一轮的循环。

3）嵌套循环

就是有循环里面还有循环，这种比较复杂，要一层一层一步一步耐心的计算，一般记住两层是处理二维数组的。

4) while（（c=getchar()）!=’\n’）和 while（c=getchar() !=’\n’）的差别

先看a = 3 != 2 和（a=3）！=2 的区别：

（！=号的级别高于=号所以第一个先计算 3！=2）第一个a的数值是得到的1；第二个a的数值是3。

考试注意点:括号在这里的重要性。

第五章

函数：是具有一定功能的一个程序块；

1) 函数的参数，返回数值（示意图）：

main()

{

int a = 5,b=6,c;

printf(“%d”,c);

}

调用函数

a,b是实参

整个函数得到一个数值就是

Add函数的返回数值。

int add ( int x, int y)

{

int z;

z=x+y;

return z;

}

被调用函数

x，y是形式参数

函数返回数值是整型

z就是这个add函数计算后得到的结果，就是函数返回给主程序的返回数值。

程序是在从上往下顺序执行，当碰到了函数add后，把a，b的数值穿给调用函数，程序暂时中断等待返回数值。当得到了返回数值后，再顺序的往下执行

2）一定要注意参数之间的传递

实参和形参之间传数值，和传地址的差别。（考试的重点）

传数值的话，形参的变化不会改变实参的变化。

传地址的话，形参的变化就会有可能改变实参的变化。

3）函数声明的考查：

一定要有：函数名，函数的返回类型，函数的参数类型。

不一定要有：形参的名称。

第六章 指针变量的本质是用来放地址，而一般的变量是放数值的。

int *p 中 *p和p的差别：

*p可以当做变量来用；*的作用是取后面地址p里面的数值

p是当作地址来使用。

*p++ 和（*p）++的之间的差别：改错题目中很重要

*p++是地址会变化。

（*p）++ 是数值会要变化。

三名主义：（考试的重点）

数组名：表示第一个元素的地址。数组名不可以自加，他是地址常量名。（考了很多次） 函数名：表示该函数的入口地址。

字符串常量名：表示第一个字符的地址。

第七章

1一维数组的重要概念：

对a[10]这个数组的讨论。

１、a表示数组名，是第一个元素的地址，也就是元素a[10]的地址。

２、a是地址常量，所以只要出现a++，或者是a=a+2赋值的都是错误的。

３、a是一维数组名，所以它是列指针，也就是说a+1是跳一列。

对a[3][3]的讨论。

１、a表示数组名，是第一个元素的地址，也就是元素a[10]的地址。

２、a是地址常量，所以只要出现a++，或者是a=a+2赋值的都是错误的。

３、a是二维数组名，所以它是行指针，也就是说a+1是跳一行。

４、a[0]、a[1]、a[2]也都是地址常量，不可以对它进行赋值操作，同时它们都是列指针，a[0]+1，a[1]+1，a[2]+1都是跳一列。

５、注意a和a[0] 、a[1]、a[2]是不同的，它们的基类型是不同的。前者是一行元素，后三者是一列元素。

二维数组做题目的技巧：

如果有a[3][3]={1,2,3,4,5,6,7,8,9}这样的题目。

步骤一：把他们写成： 第一列 第二列 第三列

a[0]à 1 2 3 －>第一行

a[1]à 4 5 6 —>第二行

a[2]à 7 8 9 －>第三行

步骤二：这样作题目间很简单：

*(a[0]+1)我们就知道是第一行的第一个元素往后面跳一列，那么这里就是a[0][1]元素，所以是１。

*(a[1]+2)我们就知道是第二行的第一个元素往后面跳二列。那么这里就是a[1][2]元素，所以是6。

一定记住：只要是二维数组的题目，一定是写成如上的格式，再去做题目，这样会比较简单。 数组的初始化，一维和二维的，一维可以不写，二维第二个一定要写

int a[]={1，2} 合法。int a[][4]={2，3，4}合法。但int a[4][]={2，3，4}非法。

二维数组中的行指针

int a[1][2]；

其中a现在就是一个行指针，a+1跳一行数组元素。搭配（*）p[2]指针

a[0]，a[1]现在就是一个列指针。a[0]+1 跳一个数组元素。搭配*p[2]指针数组使用 还有记住脱衣服法则：

a[2] 变成 *（a+2） a[2][3]变成 *（a+2）[3]再可以变成 *（*（a+2）+3）

这个思想很重要！