C语言整理

Linux命令

1. 打开终端：ctrl+alt+T 以当前地址打开新的终端：ctrl+shift+n
2. 放大字体：ctrl+shift+（+）
3. 缩小字体：ctrl(-)
4. 查看当前路径：pwd
5. 查看当前路径下有哪些文件和文件夹：ls
6. 切换路径：cd
7. 自动补全键：Tab
8. 查看文本文档：cat（适合查看比较短的文档） more（适合查看比较长的文档）
9. 创建文件夹：mkdir
10. 创建文件：touch+文件名+.格式
11. 编辑器：vi（vim）
12. 清屏：clear（ctrl+l）
13. 移动：mv
14. 复制：cp
15. 删除：rm
16. 删除空文件夹：rmdir
17. 关机：shutdown -h now
18. 重启：rebot

LinuxC开发过程

分析建模—画流程图---翻译成C语言---编译成可执行程序（）—运行

定义变量

类型名   变量名;

1.由数字,字母,下划线组成,首字母不能为数字

2.不能为关键字或保留字

3.见名知意

计算机的基本构成

输入输出设备（键盘、鼠标）

CPU处理器：（控制器，运算器，寄存器）

存储器

程序

计算机的数据表示

非数值数据（字符、图片、声音）和数值数据（二进制、八进制、十进制、十六进制）

基本数据类型

字符型：char（1字节）

整型：int（4字节）   short（2字节）   long（3os：4字节 64os：8字节）

浮点型：float（4字节）   double（8字节）

有符号数和无符号数

有符号数（signed）：有正数有负数（定义一个变量，默认是有符号的）

所有的数据都以补码的形式保存在计算机中

符号位：最高位表示该数据为正数还是负数（0表示正数，1表示负数）

正数：原码，反码，补码都是一样的

负数：

原码：直接转换为二进制，并且最高位表示符号位

反码：符号位不变，其他位取反（0变1,1变0）

补码：反码+1

无符号数（unsigned）：只有正数，并且都是数据位

字符型家族

值域范围：

Char(1字节)

unsigned char：

0000 0000 ------ 1111 1111   （0 - 255）

signed char：

有符号数：最高位要用来表示：符号（0正，1负）

1000 0000------ 0111 1111   （-128~127）

整型家族

Int （4字节 ==  32bit）

unsigned int ：

0000 0000 0000 0000 0000 0000 0000 0000 ------1111 1111 1111 1111 1111 1111 1111 1111

（0 ~ 2^32-1）

Signed int：

1000 0000 0000 0000 0000 0000 0000 0000 ----- 0111 1111 1111 1111 1111 1111 1111 1111

（-2^31 - 2^31-1）

浮点型家族

Float（单精度浮点数）：表示6~7位有效数据

%f（默认输出小数点后6位）

Double（双精度浮点数）：表示15~16位有效数据

%lf（默认输出小数点后6位）

如果想要输出小数点后n位（%.nf）

常量

定义：在程序运行期间，不会也不能被改变的量

字符常量

‘a’ ’A’  ‘b’

整型常量

二进制：1010

八进制：076

十进制：99  -2

十六进制：0xaf   0X6FC

（默认情况下，为有符号数：int、short、long）

无符号的int：66U

长整型：66L

无符号的长整型：66UL

浮点型常量

小数：3.14   10000（浮点型常量也包括整形常量）

指数：10000 = 1*10的4次方   1e+4   1e-4

%g：选择小数或者指数比较短的一种形式进行输出

^ :异或（位运算符），并不是指数

字符串常量

“hello”  “hi”

字符串以‘\0’结尾

标识常量（宏）

宏只是一个单纯的替换！！！

宏：#define  宏名  表达式

注意：

1、宏名一般用大写表示，小写也可以，因为要和普通的变量区分开来，所以用大写

2、宏后没有分号

变量

定义：就意味着要在内存空间中开辟空间

定义一个变量：

<存储类型>  数据类型   变量名；

局部变量

定义在函数体（任何函数体内）内的变量；

全局变量

定义在函数体外的变量

存储类型

存储类型：auto、static、extern、register

auto：修饰局部变量，修饰的变量存储在栈区

extern:修饰全局变量，修饰的变量存储在静态区

static：既可以修饰局部变量，也可以修饰全局变量，修饰的变量存储在静态区

1. 修饰局部变量时，延长局部变量的生命周期，如果局部变量没有初始化，其值为0；如果初始化了，则只能初始化一次；
2. 修饰全局变量时，限制作用域，该变量只能在本文件内使用

register：修饰局部变量，存储在寄存器中

初始化

初始化：在定义变量的时候就进行赋值了

生命周期和作用域

1.5.1生命周期：

从开辟空间一直到释放空间

1.5.2 作用域

使用的范围

局部变量：

生命周期：从定义开始，到模块结束（距离它最近的大括号）释放空间

作用域：大括号内

Static修饰的局部变量：

生命周期：从定义开始，到程序结束

作用域：大括号内

全局变量：

生命周期：从定义开始，到程序结束

作用域：整个程序

Static修饰的全局变量：

生命周期：从定义开始，到程序结束

作用域：本文件内

数据类型转化

强制类型转化

隐式类型转换

运算符

单算移关与，异或逻条赋

单目运算符、算术运算符、左移、右移、关系运算符、按位与、异或、按位或、逻辑运算符、

条件运算符、赋值

算术运算符

+  -  *  /  %  ++  --

%：取余

注意：不能用于浮点数

++在前：先自加，在赋值

++在后：先赋值，在自加

关系运算符

>  <  >=  <=  ==  !=

关系运算符：比较两者之间的关系，结果为（真1或者假0）

逻辑运算符

&&  ||   ！

&&

表达式1  && 表达式2

&&截断法则：有一个为假，结果就为假；前一个为假，后面就不在进行运算了

||

表达式1  || 表达式2

截断法则：有一个为真，结果就为真，前一个为真，后面就不在进行运算了

sizeof运算符

sizeof：计算所占内存空间的大小：单位：字节

sizeof（数据类型） 

sizeof（变量名）

三目运算符

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

判断表达式1是否成立，如果成立，就将表达式2的值作为整个表达式的值，否则，就将表达式3的值作为整个表达式的值

逗号运算符

表达式1，表达式2，表达式3，。。。。。，表达式n

从左往右，依次去执行每个表达式，最后将表达式n的值作为整个表达式的值

注意：逗号运算符的优先级是最低的，因此在使用时要加上括号

位运算符

&  |  ~  ^  <<  >>

按位与（&）：都为1，才为1，有一个为0，就为0

按位或（|）：都为0，才为0，有一个为1，就为1

按位取反（~）：1变0, 0变1

异或（^）：相同为0，不同为1

左移：

无符号数：高位丢弃，低位补0

有符号数：符号位不变，高位丢弃，低位补零

右移：

无符号数：低位丢弃，高位补0：

有符号数：符号位不变，低位丢弃，高位补（0正，1负）

输入输出

函数：有独立功能的模块

标准的输入输出函数：scanf、printf（对输入以及输出的变量的类型没有限制）

输入：将键盘输入数据拷贝到内存中

输出：将内存中的数据打印至终端

输出

printf（“格式控制串”，输出表）；

格式控制串：原样输出的内容+格式化符

输出表：输出的内容

（格式化符要和输出表一一对应）

整型：

%d：以十进制进行输出

%o：以八进制进行输出

%x、%X：以十六进制进行输出

#：自动在八进制和十六进之前加上前缀

%u：以无符号形式（将最高位看做数据位）进行输出

%hd：short类型

%ld：long类型

%lld：long long 类型

字符型：

%c

浮点型：

%f：float

%lf：double

%e：以指数形式进行打印

%g：选择小数和指数中较短的（合适）一个进行输出

%m.nf:

.n  ：决定的是输出小数点后n位（有小数点，但是省略n时，输出小数点后0位）

m. ：决定所占的域宽，默认右对齐，（m为负数，左对齐）m的值大于数据的实际长度时，补空格，当m的值小于实际长度时，原样输出

输入

Scanf（“格式控制串”，地址表）；

格式控制串：原样输入的内容+格式化符

&+变量名：//获取该变量的地址

注意：

1. scanf的格式控制串中不要去加多余的修饰语，如果加了，就要原样输入。
2. 如果输入“%d%d”时要给多个变量进行赋值，在格式控制串中没有间隔，那么在输入的时候，以空格、回车、Tab键作为第一个变量输入结束的标志
3. 全部输入结束后，必须以回车作为结束符
4. 如果以“%c%c”给多个字符变量进行赋值，在输入的时候不能由空格、回车、Tab作为输入结束的标志；因为空格、回车Tab也是一个字符

解决办法

1. 在%c和%c中加多余的空格或者，
2. %*c   *表示抑制符 

（抑制n个字符）%*nc

字符的输入和输出

字符的输入：

getchar( )；

返回值：获取到的字符的ascii码值

Int a = 0

getchar（）；//直接使用，不获取返回值，则相当于吃掉一个垃圾字符

字符的输出：

putchar( );

需要的参数：字符的ascii码值；

三大结构

三大结构：顺序结构、选择结构、循环结构

顺序结构

语句按照一定的先后顺序去执行

选择结构

单分支if选择结构

If（表达式）

{

语句；

}

先判断表达式是否成立，如果成立，就执行语句。

双分支if选择结构

If（表达式）

{

语句1；

}

else

{

语句2；

}

先判断表达式是否成立，如果成立，则执行语句1，否则，执行语句2；

多分支if选择结构

If（表达式1）

{

语句1；

}

Else if（表达式2）

{

语句2；

}

Else if（表达式3）

{

语句3；

}

。。。。

else  if（表达式n）

{

语句n；

}

else

{

语句n+1；

}

从上往下，依次去判断表达式是否成立，如果表达式成立，则执行对应的语句

switch语句

Switch（表达式）

{

Case 标号1：

语句1；

Case 标号2：

语句2；

Case 标号3：

语句3；

。。。。

Case 标号n：

语句n；

    default：

语句n+1；

}

注意：

1. 表达式不能为float类型
2. 标号必须为常量
3. 当表达式等于标号时，就冒号后面的语句，直到switch，case语句结束为止，或者遇到break语句结束。

循环结构

循环的起始条件

循环的终止条件

循环变量的变化

for循环

for(表达式1；表达式2；表达式3)

{

循环体；

}

表达式1：循环的起始条件

表达式2：循环的终止条件

表达式3：循环变量的变化

while语句

While（表达式）

{

循环体；

}

判断表达式是否成立，如果成立，就执行循环体，反之，跳出循环

do..while语句

do

{

循环体;

}while(表达式)；

先去执行循环体，然后判断表达式是否成立，如果成立，就继续去执行循环体内的语句，否则，结束循环

!break和continue的区别：（跳出距离自己最近的循环）

break：1、结束switch，case语句  2、跳出循环（结束循环）

continue：跳出循环（跳出本次循环，进入下一次循环）

死循环

1、

while（1）

{

循环体

}

2、

for(  ; 1 ;  )

{

循环体

}

goto语句

goto：无条件跳转语句

goto  标号：

标号：

标号的命名规则：满足标识符的命名规则；

数组

概念

一组数据类型相同的元素组和在一起

特点：1、数据类型相同   2、地址连续

定义

存储类型  数据类型  数组名[ 元素的个数 ]；

            Int    arr[5];

存储类型：auto、static、extern、register

数据类型：数组中元素的数据类型

数组的数据类型：int [5];

数据类型：去掉变量名，剩下的就是数据类型；

数组所占的内存空间的大小 = sizeof（数据类型）* 元素的个数

初始化

1. 数组定义在函数体内，如果没有进行初始化，里面的所有元素是随机值（局部变量）
2. 数组定义在函数体外，如果没有进行初始化，里面的所有元素为0（全局变量）
3. 数组定义在函数体内，并且用static进行修饰，里面的所有元素为0（静态局部变量）

访问

数组名[下标]；

注意：下标从0开始；

冒泡排序

思想：从左往右，两两依次比较，如果前一个数比后一个数大，就交换位置，反之，不变

字符数组

字符数组：保存一组char类型的数据

存储类型  数据类型  数组名[元素的个数]；

数据类型：数组中元素的数据类型

 定义： char  str[10];//定义了一个字符数组str，该数组中可以存放10个char类型的字符

数组所占的内存空间== sizeof（char）*10 = 10

数组的数据类型：char [10];//去掉数组名

字符数组的本质就是字符串;

字符串的输入输出函数

字符串的输出函数

%s：字符串

Printf(“ %s ”, str);

puts（数组名）；

功能：将数组中的内容打印到终端，并且自动换行

字符串的输入函数

Scanf(“%s”,str);

gets(数组名)；

功能：将输入的字符串保存在数组中，并且在末尾自动添加‘\0’

注意：gets不会进行越界检查，如果超出范围，就会操作未申请到的内存空间，段错误

出现段错误的原因：非法操作你没有申请的空间

字符串的处理函数

Strlen、 strcpy、strcat、strcmp

头文件：#include  <string.h>

求字符串的长度

Strlen(数组名)；

功能：求字符串的长度

返回值：求得的字符串的实际长度，不包含’\0’

字符串的拷贝函数

Strcpy（数组1，数组2/字符串）；

作用：将数组2中的内容拷贝给数组1，包含‘\0’，相当于完全拷贝

注意：数组1的容量要大于数组2

字符串的连接函数

Strcat（数组1，数组2/字符串）；

功能：将数组2中的内容连接到数组1中去，数组1中的’\0’会被覆盖

注意：数组1的容量要足够大（字符串1+字符串2）

字符串的比较函数

Strcmp（数组1/字符串1，数组2/字符串2）；

功能：比较字符串1和字符串2的大小

返回值：

大于0：字符串1 > 字符串2

等于0：字符串1 == 字符串2

小于0：字符串1 < 字符串2

比较规则：从左往右，依次去比较字符串中的每个字符的ascii值，直到遇到不同的ascii码或者遇到‘\0’，结束比较

二维数组

元素为一维数组的一维数组

1、数据类型相同  2、地址连续

（一维数组的元素的类型以及个数必须相同）

定义

定义一个二维数组：

存储类型  数据类型  数组名[行数][列数];

           Int   arr[4][3] ;

//保存了4个一维数组

行数：一维整型数组的个数

列数：一维整型数组中元素的个数

实际的元素的个数：行数*列数

内存空间的大小：sizeof（数据类型）*行数*列数

数据类型：数组最里面的元素的数据类型

二维字符数组

二维字符数组：

存储类型  数据类型  数组名[行数][列数]；

            Char    str[3][10];

//相当于定义了一个二维数组str，数组中有3个元素，每个元素又是一个拥有10个char类型的一维数组

行数：字符串的个数（一维字符数组的个数）

列数：字符串最多可以保存几个字符（一维数组中元素的个数）

函数

概念

具有独立功能的模块

为什么要使用函数

1、提高代码的复用率

2、让程序变得模块化、简洁

库函数

printf  scanf  strlen......

引入头文件

#include <stdio.h>

#include <string.h>

调用函数

函数名（参数）;

Strlen（参数）；

返回值：int（字符串的实际长度）

注意：参数的个数，以及参数的类型；返回值的类型（是否需要接收返回值）

自定义函数

自定义函数

存储类型  数据类型  函数名（形式参数列表）

{

函数体；

}

存储类型：auto、static、extern、register

数据类型: 返回值的数据类型（void）（数据类型省略不写，默认是int类型）

函数名： 见名知意

形式参数列表：（由程序员自己去确定！）要实现的功能需要几个参数，以及每个参数是什么类型

函数体：实现具体的功能

返回值：若没有返回值，void；返回值也可以省略，如果省略，默认int类型（返回有且只能有一个）

调用函数

函数名（实际参数列表）；

注意：

1. 需要将实参的值拷贝给形参，实参的个数以及数据类型要和形参一致
2. 实参，可以是变量，常量，表达式，但是必须是一个确定的值
3. 实参和形参是两块独立的空间
4. 传参，实际上是将实参的值拷贝给形参
5. 形参是局部变量，在函数调用时开辟空间，函数调用结束，立即释放

函数声明

如果函数没有写在main函数之前，就需要声明；

声明：将函数头部直接复制粘贴至main函数之前，然后加上分号

声明的作用：帮助编译器做语法检查。

指针

概念

指针是一种数据类型，它是一种保存地址的数据类型

什么是地址

内存分配的最小单元：字节

每一个字节都有一个编号，我们把这个编号就叫做地址

地址的本质：内存单元的编号

指针：指针就是地址

指针的本质：内存单元的编号

指针变量

指针 p;//p就是用来保存地址的  0x100

P：指针变量

定义

存储类型  数据类型 * 指针变量名；

           Int   * p;

数据类型：指针指向的数据类型（指针保存的是什么数据类型的变量的地址）

指针的数据类型：int *

指针的赋值

指针的赋值相当于改变指针的指向

（指针赋值时要注意 指针指向的数据类型必须相同）

空指针

指向零号地址的指针(值为0的指针，就认为该指针没有指向)

注意：零号地址禁止操作

NULL；

野指针

野指针：不知道指向哪里的指针

局部变量，没有初始化，随机值

局部指针变量，如果没有初始化，就是野指针

如何避免野指针：让她先指向0号地址。

二级指针

概念

保存一级指针的地址         //指针指针

定义

存储类型  数据类型  *指针变量名；

           Int * *pp；

数据类型：指针指向的数据类型；（二级指针指向的数据类型：一级指针的数据类型）

（int  *）

二级指针的数据类型：int **；

总结：

1. 指针的数据类型，去掉变量名就是数据类型

1. 指针指向的数据类型，去掉的一个*和变量名，剩下的就是指针指向的数据类型

1. 指针所能访问到的内存空间的大小，由指向的数据类型决定

指针的算术运算

总结：

p+n：p向地址增大的方向移动了n个数据

     p实际的变化：p + sizeof（指针指向的数据类型）*n

P-n:  p向地址见效的方向移动了n个数据

     p实际的变化：p - sizeof（指针指向的数据类型）*n

P++:  p向地址增大的方向移动了一个数据 //改变指针的指向

      p = p+sizeof（指针指向的数据类型）

P--：p向地址减小的方向移动了一个数据 //改变指针的指向

      p = p-sizeof（指针指向的数据类型）

p-q：（p和q数据类型必须相同）:这两个指针之间相隔的个数

实际的变化：（q-p）/sizeof(指针指向的数据类型)

注意：

1、指针的算数运算只有在连续的内存空间中，才有意义。

2、p是指针变量，以上的算术运算也同样应用于指针常量，但是++,--除外

指针和二维数组的关系

总结

1. &a、a、&a[0]、a[0]、&a[0][0]的值是一样的，但是表达的含义不一样

a:Int (*) [3] :他是一个指向一维数组的指针  a[0]:指向int类型元素的指针

1. 为什么说a不是int**类型？

如果a是int**类型，那么他指向的数据类型应该是int * ,那么a+1，应该移动移动4字节，但是a+1，移动了12字节，移动了一个数组，因此a一定不是int**类型

1. a指向a[0]、a[0]指向a[0][0]

数组指针

概念

指向数组的指针

//保存数组的地址

定义

存储类型 数据类型 （* 变量名） [元素的个数];

         Int （*p）[3];

//定义了一个指向数组的指针p，指向的这个数组：有3个int类型的元素

存储类型：auto、static、extern、register

数组类型：指针指向的数组中的元素数据类型

P:数组指针的数据类型: int (*)[3];

p指向的数据类型：int [3]   //去掉变量名和一个*

p+1：移动sizeof（指向的数据类型） sizeof(int [3])

指针数组

概念

元素为指针的数组

定义

存储类型  数据类型 * 变量名[元素的个数]；

Int * arr[3];

//相当于定义了一个数组，这个数组种有三个元素，每一个元素都是int *类型

数组中元素的数据类型：int *