C语言总结
- 进制转换
- 二进制、八进制、十进制、十六进制
- 二进制： 0~1（逢二进1）
- 八进制：0~7（逢八进1）
- 十进制：0~9（逢十进1）
- 十六进制：0 ~9、a~ f（A~F）（逢16进1）
- 为了区分不同的进制：八进制前加0，十六进制前0x（0X）(0x7fa 0X7FA)
- 十进制：76 八进制：076 十六进制：0x76、0X76
- 其他进制转十进制：(注意：从右往左：从0次幂开始)
- 二进制转十进制：1010 0101 = 1*2^0+1*2^2+1*2^5+1*2^7
- 八进制转十进制：076=6*8^0 + 7*8^1
- 十六进制转十进制：0xafc = 12*16^0+15*16^1+10*16^2
- 十进制转其他进制：
- 十进制转二进制：除2倒取余数
- 十进制转八进制：除8倒取余数
- 十进制转十六进制：除16倒取余数
- 二进制和八进制：（将每一个
- 八进制数用三个bit的二进制数去表示）
2、基本的数据类型
2.1基本数据类型
关键字：系统预先定义好的，有特殊含义的，并且都是小写，不能重新定义
一共有32个：
数据类型：char、short、int、long、float、double、enum、union、struct、void
控制语句：if、else、for、do、while、switch、case、default、break、continue、goto
存储类型：auto、static、extern、register
const：只读
return：返回函数
signed：有符号数
unsigned：无符号数
sizeof：计算所占内存空间的大小：单位：字节
typedef：给一个已有的数据类型起别名
volatile: 防止编译器优化
标识符：程序员自己定义的，一般用来定义变量名，函数名，类型名
命名规范：（见名知意）
32os：分别占据多少个字节：
字符型：char（1字节）
整型：int（4字节） short（2字节） long（4字节）
浮点型：float（4字节） double（8字节）
64os：
字符型：char（1字节）
整型：int（4字节） short（2字节） long（8字节）
浮点型：float（4字节） double（8字节）
2.2、转义字符
3、常量
定义：在程序运行期间，不会也不能被改变的量
3.1、整型常量
二进制：1010
八进制：076
十进制：99 -2
十六进制：0xaf 0X6FC
（默认情况下，为有符号数：int、short、long）
无符号的int：66U
长整型：66L
无符号的长整型：66UL
3.2、浮点型常量
小数：3.14 10000（浮点型常量也包括整形常量）
指数：10000 = 1*10的4次方 1e+4 1e-4
//error：（1*10^4）
%g：选择小数或者指数比较短的一种形式进行输出
^ :异或（位运算符），并不是指数
3.3、字符串常量
hello” “hi”
字符串以‘\0’结尾
3.4、标识常量（宏）
宏只是一个单纯的替换！！！
宏：#define 宏名 表达式
注意：
1、宏名一般用大写表示，小写也可以，因为要和普通的变量区分开来，所以用大写
2、宏后没有分号
4、变量
定义：就意味着要在内存空间中开辟空间
如何定义一个变量？
<存储类型> 数据类型 变量名；
存储类型：决定了开辟的空间在内存空间中的哪个分区
数据类型：决定了开辟的内存空间的大小
变量名：开辟的内存空间的名字
存储类型：auto、static、extern、register
存储类型：auto、static、extern、register
auto：修饰局部变量，修饰的变量存储在栈区
extern:修饰全局变量，修饰的变量存储在静态区
static：既可以修饰局部变量，也可以修饰全局变量，修饰的变量存储在静态区
register：修饰局部变量，存储在寄存器中；
auto：修饰局部变量，修饰的变量存储在栈区
register：修饰局部变量，修饰的变量存储在寄存器中，建议将变量存储在寄存器中，提高运行速度，但是寄存器中的内存空间很小，因此，当用register修饰时，如果寄存器中已满，变量就会存储在栈区
extern：修饰全局变量，修饰的变量存储在静态区
程序可以由多个.c构成，但是只能有一个main函数
Static：即可以修饰全局变量，也可以修饰局部变量
修饰局部变量时，延长局部变量的生命周期，如果局部变量没有初始化，其值为0；如果初始化了，则只能初始化一次；
（延长了生命周期，但是并没有延长作用域！！）
5、运算符
单算移关与，异或逻条赋
单目运算符、算术运算符、左移、右移、关系运算符、按位与、异或、按位或、逻辑运算符、
条件运算符、赋值
算术运算符
+ - * / % ++ --
%：取余
注意：不能用于浮点数
++在前：先自加，在赋值
++在后：先赋值，在自加
注意：如果a++或者++a，单独成立一条语句，都相当于给a加1；
关系运算符
> < >= <= == !=
关系运算符：比较两者之间的关系，结果为（真1或者假0）
//注意 (0 < a < 5) error
等号的书写：将常量写在等号的左边
逻辑运算符
&& || ！
&&
表达式1 && 表达式2
&&截断法则：有一个为假，结果就为假；前一个为假，后面就不在进行运算了
||
表达式1 || 表达式2
截断法则：有一个为真，结果就为真，前一个为真，后面就不在进行运算了
sizeof运算符
sizeof：计算所占内存空间的大小：单位：字节
sizeof（数据类型）
sizeof（变量名）
三目运算符
表达式1 ？ 表达式2 ：表达式3
判断表达式1是否成立，如果成立，就将表达式2的值作为整个表达式的值，否则，就将表达式3的值作为整个表达式的值
逗号运算符
表达式1，表达式2，表达式3，。。。。。，表达式n
从左往右，依次去执行每个表达式，最后将表达式n的值作为整个表达式的值
注意：逗号运算符的优先级是最低的，因此在使用时要加上括号
6、三大结构
三大结构：顺序结构、选择结构、循环结构
顺序结构
语句按照一定的先后顺序去执行
单分支if选择结构
If（表达式）
{
语句；
}
先判断表达式是否成立，如果成立，就执行语句。
3.2.2 双分支if选择结构
If（表达式）
{
语句1；
}
else
{
语句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；
}
注意：
表达式不能为float类型
标号必须为常量
当表达式等于标号时，就冒号后面的语句，直到switch，case语句结束为止，或者遇到break语句结束。
switch，case语句是否结束）
是否遇到了break）
for循环
for(表达式1；表达式2；表达式3)
{
循环体；
}
表达式1：循环的起始条件
表达式2：循环的终止条件
表达式3：循环变量的变化
先执行表达式1，然后执行表达式2，如果表达式2为真，执行循环体，然后执行表达式3；如此反复，当表达式2为假时，结束循环
while语句
While（表达式）
{
循环体；
}
do..while语句
do
{
循环体;
}while(表达式)；
先去执行循环体，然后判断表达式是否成立，如果成立，就继续去执行循环体内的语句，否则，结束循环
7、数组
7.1一维数组
概念
一组数据类型相同的元素组和在一起
特点：1、数据类型相同 2、地址连续
定义
存储类型 数据类型 变量名；
Int a；
存储类型 数据类型 数组名[ 元素的个数 ]；
Int arr[5];
存储类型：auto、static、extern、register
数据类型：数组中元素的数据类型
数组的数据类型：int [5];
数据类型：去掉变量名，剩下的就是数据类型；
数组所占的内存空间的大小 = sizeof（数据类型）* 元素的个数
总结：
数组定义在函数体内，如果没有进行初始化，里面的所有元素是随机值（局部变量）
数组定义在函数体外，如果没有进行初始化，里面的所有元素为0（全局变量）
数组定义在函数体内，并且用static进行修饰，里面的所有元素为0（静态局部变量）
7.2二维数组
概念
数组：一堆数据类型相同的元素组和在一起
整形数组：一堆int类型的元素组合在一起
字符数组：一堆char类型的元素组合在一起
二维数组：（数组数组）：一堆数组的元素组合在一起
元素为一维数组的一维数组
定义
存储类型 数据类型 数组名[元素的个数]；
Int a[3];
//定义了一个有五个int类型元素的数组
数据类型：元素的数据类型
一维数组的数据类型：int[3];
定义一个二维数组：
存储类型 数据类型 数组名[行数][列数];
Int arr[4][3] ;
//保存了4个一维数组
行数：一维整型数组的个数
列数：一维整型数组中元素的个数
实际的元素的个数：行数*列数
内存空间的大小：sizeof（数据类型）*行数*列数
数据类型：数组最里面的元素的数据类型
7.3、字符数组
整型数组：保存一组int类型的数据
存储类型 数据类型 数组名[元素的个数]；
数据类型：数组中元素的数据类型
Int arr[5];
字符数组：保存一组char类型的数据
存储类型 数据类型 数组名[元素的个数]；
数据类型：数组中元素的数据类型
定义： char str[10];//定义了一个字符数组str，该数组中可以存放10个char类型的字符
数组所占的内存空间== sizeof（char）*10 = 10
数组的数据类型：char [10];//去掉数组名
Int： 10, 20, 30
Float：3.14 4.165
Char：‘a’ ‘b’
字符串：用什么保存？“hello” = ‘h’‘e’‘l’‘l’‘o’‘\0’
用字符数组来保存！
给字符数组清零：
7.4、二维字符数组
二维整形数组
定义一个二维整型数组：
存储类型 数据类型 数组名[行数][列数];
Int arr[4][3] ;
//数据类型：二维数组最里面的元素的数据类型
二维字符数组：
存储类型 数据类型 数组名[行数][列数]；
Char str[3][10];
//相当于定义了一个二维数组str，数组中有3个元素，每个元素又是一个拥有10个char类型的一维数组
行数：字符串的个数（一维字符数组的个数）
列数：字符串最多可以保存几个字符（一维数组中元素的个数）
冒泡排序
56 12 34 78 66 --------------------- 12 34 56 66 78
思想：从左往右，两两依次比较，如果前一个数比后一个数大，就交换位置，反之，不变
8、指针
概念
指针是一种数据类型，它是一种保存地址的数据类型
Int是一种数据类型，它是一种保存整形数的数据类型
Char是一种数据类型，它是一种保存字符的数据类型
2、定义
存储类型 数据类型 * 指针变量名；
Int * p;
//定义了一个指针变量p,p用是用来保存（谁的（int）地址）地址
数据类型：指针指向的数据类型（指针保存的是什么数据类型的变量的地址）
指针的数据类型：int *
注意：*和&互逆
二级指针
概念
Int *p; //用来保存int类型变量的地址 //整形指针
Char *p；//用来保存char类型变量的地址 //字符指针
Float *p；//用来保存float类型的变量的地址 //浮点型指针
保存一级指针的地址 //指针指针
定义
存储类型 数据类型 *指针变量名；
Int * *pp；
数据类型：指针指向的数据类型；（二级指针指向的数据类型：一级指针的数据类型）
（int *）
二级指针的数据类型：int **；
总结：
指针的数据类型，去掉变量名就是数据类型
Int *p; // int *
Int **p; //int **
Int ***p; // int ***
指针指向的数据类型，去掉的一个*和变量名，剩下的就是指针指向的数据类型
Int *p； // p指向的数据类型为int
Char *h；//h指向的数据类型char
Int **q；//q指向的数据类型为int *
Char **s；//s指向的数据类型为 char *
Int ***t；//t指向的数据类型 int **
3、指针所能访问到的内存空间的大小，由指向的数据类型决定
Char a = ‘b’；
Char *p = &a；//p能访问到的内存空间1字节
int a；
Int *q = &a;//q能访问到的内内存空间的大小：4字节
Int **s ;
S = &q;//s所能访问到的内存空间的大小：4字节
4、
Int **p；
Int ** *q；
q = &p;
数组指针
2.1 概念
指向数组的指针
//保存数组的地址
2.2 定义
存储类型 数据类型 （* 变量名） [元素的个数];
Int （*p）[3];
//定义了一个指向数组的指针p，指向的这个数组：有3个int类型的元素
存储类型：auto、static、extern、register
数组类型：指针指向的数组中的元素数据类型
P:数组指针的数据类型: int (*)[3];
p指向的数据类型：int [3] //去掉变量名和一个*
p+1：移动sizeof（指向的数据类型） sizeof(int [3])
数组指针和一维数组的关系
指针数组和二维数组的关系
扫一扫
7615
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
