C语言知识点总体梳理(知识点)

一、数据的表现形式

1、常量

（1）整型常量

（2）实型常量：十进制小数形式（由数字和小数点组成）、指数形式（12.34e5，e或E之前和之后必须有数字、之后的数字必须是整数）

E表示10的多少次方，次方跟在E后

（3）字符型常量：普通字符（单引号括起来的单个字符，以ascii码值存放，）、转义字符（以\开头的字符序列P40）

（4）字符串常量：双引号括起来的任意字符

（5）符号常量：用#define指令，指定用一个符号名称代表一个常量，好处见名知意、一改全改，注意符号常量不占内存，编译后，符号不存在
#define PI 3.1416 //行末没有引号

案例：区分1、‘1’、“1”，分别是整形常量 、字符常量 、字符串

2、变量

（1）先定义后使用

（2）变量有三要素，变量名，变量地址，变量的值

（3）标识符(变量的名字)：字母、数字、下划线，不能以数字开头，区分大小写，自定义的标识符不能是关键字

二、数据类型

数据类型（决定了数据占用的内存空间及存储形式，决定了数据可以参与的运算，C标准并没有规定每种类型占用的字节数，由编译系统自行决定（P45）、sizeof运算符，可以测量变量或类型的长度，占用的字节数，决定了可以表示数的范围）

1、各种数据类型

（1）整型

（2）字符型：字符型在一定范围内可以和整型通用(P48)

（3）实型（浮点型） ：实数以指数形式存储

注意：只有整型、字符型可以使用signed或unsigned修饰，实型不可以，无符号整型用%u输出

用有限的单元不能完全精确地存储一个实数

2、确定常量的类型

2----int
2L----long
3.4----double
3.4f----float

3、数据的输入输出（C语言本身不提供输入、输出操作，由库函数完成）

（1）输入

1） int scanf(char * format,args,…);
scanf(“a=%d”,&a); （P75注意事项）

char * 相当于字符串格式，用字符数组进行存放----char ch[10]=“a=%d”；

格式控制字符串：以%开头的格式控制符（P74,与输入项对应），以及其他普通字符（原样输入）
读入double类型的数值的时候后面别忘了加f
输入项（地址表列）：变量的地址

2) int getchar(); ------从标准输入设备输入一个字符 ，空格、回车、tab等都是有效字符

char c=getchar()

#include <stdio.h>
#define SIZE 10
void findmax( int *px,int n,int *pmax );
int main()
{
    int a = getchar();
    printf("a=%d\n",a);
    
    char c = getchar();
    printf("c=%c\n",c);
}

如果输入的是数字，自动转换为字符型

（2）输出

int printf(char * format,args,…) 返回输出字符的个数
printf(“a=%d”,a);

格式控制字符串：以%开头的格式控制符（与输出项对应），以及其他普通字符（原样输出）

输出项：变量

（3）int putchar(char ch); 输出一个字符

putchar(getchar())
char c=’y’;
putchar©;

#include <stdio.h>
void findmax( int *px,int n,int *pmax );
int main()
{
    int a = getchar();
    putchar(a);
    
    char c = getchar();
    putchar(c);
    printf("\n");
}

4、sizeof的使用

#include <stdio.h>
#define SIZE 10
void findmax( int *px,int n,int *pmax );
int main()
{

    printf("一个int类型的值所占的字节为：%lu\n",sizeof(int));
    printf("一个float类型的值所占的字节为：%lu\n",sizeof(float));
    printf("一个char类型的值所占的字节为：%lu\n",sizeof(char));
    printf("一个double类型的值所占的字节为：%lu\n",sizeof(double));
    int a[5];
    printf("一个int类型的数组:a[5]所占的字节数为：%lu\n",sizeof(a));
    printf("a数组的长度为：%lu\n",sizeof(a)/sizeof(int));
    double b[3][4];
    printf("一个double类型的二维数组：b[3][4]所占的字节数为：%lu\n",sizeof(b));
    printf("b数组的长度为：%lu\n",sizeof(b)/sizeof(double));
}

三、运算符（对数据进行加工）运算规则、优先级结合性、表达式的值

1、算术运算符

1） 算术运算符：+、-、*、/（两个整数相除结果为整数）、%（操作数必须为整数）、++、 – （只能用于变量，分清前缀后缀）

int  a=3,c;
c=a++;  c= 3 a=4   ==>c=a; a++
c=++a;   c=4,a=4    ==>a++ ;c=a

2.5/2=1.25
5/2=2
(a+b)++ 错误

2） 结合性：自左至右
3） 算术表达式的值：计算结果

2、赋值运算符

1) 基本赋值运算符=，将右侧的值赋给左侧的变量
int a,b; a+b=5(错误)

2) 复合赋值运算符，例如+=
a+=b<===> a=a+(b)
括号不要忘记 a一定是变量，b是表达式（一个变量或常量是最简单的表达式）

int a=2,b=3,c;
c*=a+b; ===>c=c*(a+b) 一定别忘记括号

3) 结合性：自右至左

int a,b,c=8;a=b=c ===>a=(b=c)

int a,b,c; a=b+1=c+2;===>a=(b+1=c+2) 错误
int a=b=3; 错误，b未声明
int a=3,b=3; 或 int a,b; a=b=3;正确

4) 赋值表达式的值：赋值运算符左侧变量的值
5) 赋值运算符两侧的类型转换：两侧的类型都是数值型，以左侧变量的类型为准，由系统自动完成
例如

double a=1; ==>a=1.0

int a=3.4; ==>int a=(int)3.4 -->a=3(有精度损失的警告，但不影响运行，但在java中报编译错误)

3、关系运算符

1）符号 、！、=、 >、 <、 >=、 <=

2)运算规则 注意区分=和==

3）结合性：自左至右

4）关系表达式的值 1（表达式成立，真）或0（表达式不成立，假）

int x=5;
10<=x<=99 关系表达式自左至右求解，先求10<=x,则表达式不成立表达式的值为0 ，接下来继续求解0<=99 ,结果为1

不论x的值是多少，表达式10<=x<=99的值恒为1

4、逻辑运算符

1）符号 &&逻辑与、 ||逻辑或（双目运算符）、 ！逻辑非（单目运算符）

2）运算规则 （a,b可以为一个常量或变量或表达式）

a&&b，a,b两者同为真（非零为真，否则为假）时，结果为真

a||b，a,b同时为假，结果为假，否则结果为真

!a，取反，a为真，结果为假，a为假结果为真

系统如何判断一个量的真假：非零为真，0为假

系统如何表示真假：1–真 0----假

3)结合性：自左至右

4)逻辑表达式的值为1或0，成立（真）为1，否则为0

a=3,b=4,c=5

((a+b)>c)&&(b==c)	逻辑表达式 值为0
a||((b+c)&&(b-c))	短路现象 1
((!(a>b))&&(!c))||1	不存在短路现象 1
(!(x=a))&&(y=b)&&0	短路现象 0
((!(a+b))+c-1)&&(b+c/2)	1

5）短路现象：存在于&&和||中，

a&&b，当a为假的时候，不需要计算b的值，就可以直接得到整个逻辑表达式的值为假，这个现象称为短路现象

a||b，当a为真的时候，不需要计算b的值，就可以直接得到整个逻辑表达式的值为真，这个现象称为短路现象

例如

a=3,b=4,c=5
x=1，y=2则执行下面的表达式后，x=3，y=2（短路现象）
(!(x=a))&&(y=b)&&0

5、条件运算符

符号表达式1？表达式2：表达式3 二分支结构

运算规则，求解表达式1，为真则求解表达式2，并将表达式2的结果作为整个条件表达式的结果，否则求解表达式3，并将表达式3的结果作为整个条件表达式的结果

等价于二分支结构

if(表达式1)
表达式2
else
表达式3

6、逗号运算符 ，

1）规则：自左至右求解，并将最后一个表达式的值作为整个逗号表达式的值

7、间接引用运算符*：后面只能跟地址，表示的是地址指向的内存

int a; ---------- *&a<===>a

8、地址运算符 &：后面只能跟变量

int a;int *p=&a; &a=====p 均指整型变量a的地址
int *p; &p-----代表指针变量的地址，合法

三、流程控制

1、顺序

2、选择（分支）

（1）if语句

语法：

if(表达式)
   语句

注意：
1） 表达式是任意合法的表达式，表达式后不能加分号
2） 语句为一条语句，如果有多条，需要用大括号构成复合语句
3）执行：如果表达式成立（为真，非零为真），则执行语句

（2）if…else语句

语法：

if(表达式)
   语句1
   else
   语句2

注意：
1）表达式是任意合法的表达式
2）语句1、2为一条语句，如果有多条，需要用大括号构成复合语句
3） else表示的情况与if完全相反，并且else必须和if配对使用
4） 执行：如果表达式成立（为真，非零），则执行语句1，否则执行语句2
案例，else必须和if配对

程序报错

else总是和离它最近没有配对的if配对，可以用大括号改变配对（P108，第七题），else不能单独使用

（3）if语句的嵌套

（4）switch 语句—多分支语句（开关语句）

语法：

switch(表达式)
{
	case 常量表达式1:语句1；
	case 常量表达式2:语句2；
	case 常量表达式3:语句3；
	….
	default:语句n；
}

注意：

1）表达式可以为任意合法的表达式，但其值必须为整型（字符型）
2）case后面必须是常量表达式，并且不能重复
3）case后面的语句可以有多条，不必加括号
4）执行：首先计算表达式的值，然后将其和case后面的常量比对，如果相等，则执行case后面的语句，一直到结束，除非遇到break语句，结束swtich语句
5）多个case可以共用一条语句
6）break ，default不是必须的

3、循环结构——重复，次数确定或不确定

循环变量的初始值、循环条件、循环体（一条语句，循环体中有使循环条件趋于不成立的语句）

（1）While语句

语法

while(表达式)//循环条件，后面没有分号
{
       语句  //循环体，包含使循环条件不成立的语句
}

注意：

1）表达式为任意合法的表达式，当表达式为真时，执行循环体，当表达式为假，结束循环，循环体最少执行0次

（2）do…while语句

语法：

do
{
  语句//循环体，包含使循环条件不成立的语句
}while(表达式); //循环条件，后面有分号

注意：
1）表达式为任意合法的表达式，先执行语句，然后判断循环条件，当表达式为真时，继续执行循环体，当表达式为假，结束循环，循环体至少执行1次

（3）for语句

语法：

for(表达式1;表达式2;表达式3)//后面没有分号
{
	语句
}

注意：
先执行表达式1，然后判断表达式2，如果为真则执行语句，然后执行表达式3，如果为假则结束循环

三个表达式都可以省略，分号不可以省略

表达式1通常为循环初始条件，表达式3通常为循环变量的改变

4、break\continue

break 结束其所在的循环

continue结束本次循环，接着进行下一次循环条件的判断

continue在for循环中会接着执行表达式3，然后判断循环条件

典型案例：求和、计数器、分离各个位数字、素数、斐波那契数列、每行输出几个数、输入一行数以#号结束（P136）、菱形图案、判断几位数

四、数组 批量同类型数据，数组元素在内存中连续存放，数组名代表数组首地址，是一个地址常量、构造类型（根据一定的规则，利用基本类型构造而成）

1、一维数组

（1）数组声明

语法：
类型 数组名[常量表达式]；

注意：
1） 类型是任意合法的类型
2） []里一定是常量，代表数组元素的个数

（2）数组初始化（定义的同时赋值）

Int a[10]={1,2,3,4}//可以全部赋值，可以部分赋值（其余元素都是默认值），如果全部赋值，则数组大小可以省略

例如:Int a[]={1,2,3,4}等价于int a[4]={1,2,3,4}

注意：除了初始化时可以给所有元素赋值，否则，定义完数组时，只能逐个元素赋值

Int a[10];//10代表是数组元素的个数
a[10]={1,2,3,3};//错误10代表数组元素的下标
a={1,2,4};//错误

（3）数组元素的引用

语法：
数组名[下标]

注意：
不能一次性引用数组元素，只能逐个引用，下标从0到数组大小减1，通常利用循环遍历数组

（4）常见算法

遍历、最值、排序、逆置、增删改查

2、二维数组：一维数组的数组

存放批量同类型数据，数组元素在内存中连续存放（按行存放，第一行存放完再存放第二行…），数组名代表数组首地址，是一个地址常量

（1）数组声明

语法：
类型 数组名[常量表达式] [常量表达式]；

注意：
1）类型是任意合法的类型
2）[]里一定是常量，代表数组元素的个数

（2）数组初始化（定义的同时赋值）

Int a[10][3]={{1,2,3,4},{}}//可以全部赋值，可以部分赋值（其余元素都是默认值），如果全部赋值，则数组第一维大小可以省略

例如:
Int a[2][3]={1,2,3,4,5,6}
等价于a[][3]={1,2,3,4,5,6}

注意：除了初始化时可以给所有元素赋值，否则，定义完数组时，只能逐个元素赋值

（3）数组元素的引用

语法
数组名[行标][列标]

通常用双层循环遍历二维数组，外层控制行，内层控制列

（4）常见算法

遍历、最值、转置（行列互换）、上下三角

3、字符数组：存放字符

(1)数组声明语法：

char 数组名[常量表达式]；

(2)初始化

Char a[10]={‘h’,’i’}//可以全部赋值，可以部分赋值（其余元素都是默认值），如果全部赋值，则数组大小可以省略

Char ch[]={“hello”} ==>char ch[]=”hello”//字符串结束标志\0 数组ch长度为6（包含\0）
字符串结束标志\0,但字符数组可以不包含\0

(3)数组元素引用

数组名[下标]

(4)字符数组的输入、输出

C对于字符串（双引号括起来的若干个字符），自动追加\0代表字符串结束标志，所有的字符串一定放在字符数组中存放

1) 逐个字符输入、输出 %c
2) 以字符串的形式一次输入、输出 %s

例如
char ch[10];
scanf(“%c”,&ch[0]);//%c逐个输入
scanf(“%s”,ch) //输入项为字符数组名，输入的字符串中不能包含空格（空格，回车，tab为字符串结束标志）
printf(“%c”,ch[0]);
printf(“%s”,ch);//输出字符串，一直到遇到第一个\0

(5)字符串处理函数

puts 输出字符串（\0结束的字符序列），将\0转换为换行，即输出字符串后换行------stdio.h
int puts(char * str)
puts(“strss”);

gets 输入一个字符串------stdio.h
char *gets(char *str); 输入一个字符串存放在str指向的内存中，同时返回这个地址

strcat---------字符串连接 string.h

Char * strcat(char *str1,char * str2 ) //str2连接到str1后面，返回str1
注意：str1指向的内存空间要足够大

strcpy -----字符串复制string.h

char * strcpy(char *str1,char *str2);//str2复制到str1,返回str1

Str1指向的空间应该足够大

char ch1[]=”hello”;
char ch2[];
ch2=ch1;//错误

Char * Strncpy(char *str1,char *str2,int n);//将str2前n个字符复制到str1

strcmp-----字符串比较函数 string.h
Strlen----字符串长度
Strlwr------转换为小写 char *strlwr(char *s)
Strupr------转换为大写

五、函数 (function)—完成一定功能的模块（算法），实现代码的复用

1、 函数的定义--------- 不可以嵌套定义，可以嵌套调用

1）函数的分类 库函数----自定义函数
从函数的形式分，分为有参函数和无参函数

2）函数的定义：分为函数首部（函数头），函数体两部分
语法：
返回值类型（函数类型） 函数名（形参表列）--------函数首部
{
说明部分（变量定义或函数声明） --------函数体
执行部分（语句）
}

注意：
返回值类型(函数的输出)的确定，首先判断函数是否需要返回一个值，如果需要再看返回值的类型，如果没有返回值，则明确声明为void,一定注意，返回值只能有一个，如果多于一个，只能通过别的方式带回，此时也将函数返回值类型声明为void

函数名：一个合法的标识符，尽量见名知意，多个单词连用，通常除了第一个单词外，其余单词首字母大写

形参表列：形参1类型 形参1名，形参2类型 形参2….,一个函数可以有多个形参，形参之间用逗号隔开，形参名是任意合法的标识符。是函数完成其功能时，所需要的必要的已知条件，相当于函数的输入，如果函数不需要已知条件，则空着，此时是无参函数。

函数体，是函数功能的具体实现（算法的具体实现），此时形参相当于已经有值(在函数调用时，由实参传递过来的值),不需要重新赋值，如果函数需要返回一个值，用return 语句带回（return语句将后面表达式的值带回到函数调用处，并结束函数的调用，return后面可以不加表达式，此时仅仅结束函数的调用，return语句可以有多个，但只有一个会执行）

例如：

1、 求两个数的和

double add(double x,double y)
{
    return x+y;
 }

2、 求两个整数的最大值

int max(int x,int y)
{
   return (x>y)?x:y;
}

3、 求1-100的和

int sum()
{
  int s=0,i;
for(i=1;i<=100;i++)
  s+=i;
return s;
 
}

4、 求两个整数的最大公约数

int fun(int x,int y)
{
}

5、 求两个整数的最小公倍数

int fun2(int x,int y)
{
}

6、判断一个数是否是素数

int isSushu(int x)
{
}

2、函数的调用

语法：
函数名（实参表列）

注意：
实参表列，实参可以是常量，变量或表达式。要求实参的个数和形参一致，类型和形参赋值兼容（形参1=实参1），实参必须有确定的值 i

如果要使用函数的返回值，可以定义一个和函数返回值类型一致的变量，接收返回值

案例，调用上面写的函数

1、 double s=add(3.5,5.6);//用常量做实参

或者
double x=3.5,y=5.6;
double s=add(x,y)；//注意x,y是变量做实参，但x，y已经有确定的值
add(x+y,xy)//表达式做实参，求x+y和xy的和
add(a,add(a,b))add(a,b)&&1

注意：

1、 在发生函数调用时，首先程序执行的流程转到被调用函数，会给被调用函数的局部变量（定义在函数内部的变量，包括形参）分配内存空间，会将实参的值对应地传给形参

2、 在函数调用结束时（return语句或遇到函数体结束的右括号），程序执行的流程转到主调函数中函数调用处，回收被调用函数的局部变量（定义在函数内部的变量，包括形参）所占内存空间，如果需要return返回1个值，则把这个值带回函数调用处
因此，除了main函数外，其他函数中的局部变量只在被调用期间占有内存空间，不同函数的局部变量可以重名，仅仅是重名，一定占用不同的内存空间

3、函数调用时的参数传递

（1）普通变量（包括数组元素）做函数参数 由实参将值对应地传递给形参，传值调用(形参的改变不会影响实参)

（2）数组名做函数参数，由实参将值（地址）对应地传递给形参（传址调用）数组名就相当于一个指针

案例，函数完成数组排序：
void sort(int a[4]) ===》 void sort(int a[]) ====》 void sort(int *a)

如果指针指向数组，则指针变量可以带下标，此时指针变量相当于数组名

 {
        int i,j,t;
        for(j=10;j>1;j--)
            for(i=0;i<j-1;i++)
            {
                if(a[i]>a[i+1])
                {
                    t=a[i];
                    a[i]=a[i+1];
                    a[i+1]=t;
                }
            }
    }

4、函数的声明

编译系统自上而下编译代码，首先检查语法问题，没有问题则生成.obj文件，如果没有进行函数声明，编译系统自动地认为函数的类型（返回值的类型）是int型

以下代码中，f函数的类型为void，并且写在主调函数后，运行时报错，type mismatch in redeclaration of ‘f’，因此如果被调用函数如果写在主调函数后，且函数类型不是int，则必须添加函数声明

例如以下代码，在主调函数中并没有对被调用函数进行声明，程序可以正常执行，但此时存在风险 ，将下面红色字体的代码变成printf(“%d”,max3(x,y))；时程序不报错，但运行结果不对，如果有函数声明，则此时红色字体的代码变成printf(“%d”,max3(x,y))；时程序会报错 too few parameters in call to max3 in function main

函数声明（函数原型声明）：
当被调用函数写在主调函数之后，此时可以在主调函数中，对被调用函数进行声明，方便编译系统检查函数调用表达式的正确性（检查项包括函数的类型、函数名字、参数的类型和个数）。

如果被调用函数写在主调函数之前，此时函数声明可以省略。

函数声明的语法： 函数返回值类型 函数名（形参1的类型,…）；
或者函数返回值类型 函数名（形参1的类型 形参1，形参2类型 形参2）；