c语言学习笔记分享

用计算机语言 告诉计算机 人类要解决的问题

数据类型:

新生儿的数量 整数
身高体重 小数
统计名字 字符数据

计算机世界
0 1

1+2 ALU
1.0+2.0

GPU //浮点(小数)运算

不同类型的数据 — 机器指令不同 — 最终使用硬件的部件 不同

基本数据类型:
整型
浮点型
字符型

常量
变量

在程序运行过程中，
值不能被改变的量 --常量
值能被改变的量 --变量

整型:
常量形式:
123 //十进制
0x123 //十六进制
0123 //八进制

进制:
进位的制度
逢几进一

十进制:
0 1 2 3 4 5 6 7 8 9
10 11 12 13 … 19
20 21 … 29

十六进制: // 10 11 12 13 14 15
0 1 2 3 4 5 6 7 8 9 a b c d e f
10 11 12 … 1a 1b … 1f
20 …

八进制:
0 1 2 3 4 5 6 7
10 11 12 13 …

0 1 //二进制

十进制 转 二进制

除2取余法

 2|123
  ----
  2|61 ... 1                  ----低位
   --
   2|30 ... 1 
    ---
	 2|15  ... 0
	  ---
	   2|7   ... 1
	    --
		2|3   ... 1
          --
		  2|1    ... 1
		   --
		    0     ...  1        ---高位 
		
		
	0111 1011 

二进制转十进制:
加权求和

BCD码
8 4 2 1
1 0 1 1

十六进制 <=> 二进制

1位十六进制数 对应 4位 二进制数
0000

0111 1011
7 b

123

八进制 <=> 二进制
1位八进制数 对应 3位 二进制数

001 111 011
1 7 3
变量形式:
描述一个变量

语法:
数据类型 变量名;

整型:
int //
short //
long //
long long //

signed / unsigned

int a;

变量名起名: //标识符
1.数字，字母，下划线
2.数字不是开头
3.区分大小写
4.不能与关键字重名
5.不要和系统二级关键词重名 (include 预处理的命令)
6.不能与库函数重名

int a = 10; //初始化 开空间的同时给了值

int a; //先开空间 后给值
a = 10; // 赋值

int a = 0x12345678;

大端存储
小端存储
高高低低

高位数据 存储在 高地址处
低位数据 存储在 低地址处

int a = 123;

//123
//
0000 0000 0000 0000 0000 0000 0111 1011
001
int a = -123;

补码:

模
取模
12 - 5 = 7
12 + (-5) = 7
12 + 7 = 19 （12 + 7） ==> 7

0 1 2 3 4 5 6 7 8 9
0

-123
数据最高位 充当符号位
0 正
1 负

符号位|—数值位
0|000 0000 0000 0000 0000 0000 0111 1011 //+123
1|000 0000 0000 0000 0000 0000 0111 1011 //-123

补码:
//负数
原码
1|000 0000 0000 0000 0000 0000 0111 1011 //-123
反码
符号位不变，其余位按位取反
1|111 1111 1111 1111 1111 1111 1000 0100 //-123
补码 反码 + 1
1|111 1111 1111 1111 1111 1111 1000 0101 //-123
f f f f f f 8 5

有符号数
有一位为符号位
包含了 正数 负数
无符号数
不包含符号位
包含非负数

unsigned int
signed int

unsigned int

0000 0000 0000 0000 0000 0000 0111 1011 //-123

结论：
整数 计算机中存的都是补码

正数:
原码 反码 补码 都是一样的

负数:
补码 = 反码 + 1
练习:
-6735

   1|000 0000 0000 0000 0001 1010 0100 1111 //原码 
   1|111 1111 1111 1111 1110 0101 1011 0000 //反码 
   1|111 1111 1111 1111 1110 0101 1011 0001 //补码 
     f    f    f    f    e    5    b    1 

练习:
5678
-5678

0000 0000 0000 0000 0001 0110 0010 1110 //5678
0 0 0 0 1 6 2 e

1|000 0000 0000 0000 0001 0110 0010 1110 //-5678
1|111 1111 1111 1111 1110 1001 1101 0010 //-5678 补码
f f f f e 9 d 2

unsigned int

0000 0000 0000 0000 0000 0000 0000 0000 //最小值
1111 1111 1111 1111 1111 1111 1111 1111 //最大值

•                                 1
  

---

1 0000 0000 0000 0000 0000 0000 0000 0000 2^32 - 1 //42亿多

signed int [-2^31 ~ +2^31-1]

0|000 0000 0000 0000 0000 0000 0000 0000 //最小值
0|111 1111 1111 1111 1111 1111 1111 1111 //2 ^ 31 - 1 //21亿多

1|000 0000 0000 0000 0000 0000 0000 0000 //最小值
1|111 1111 1111 1111 1111 1111 1111 1111 //2 ^ 31 - 1 //21亿多

1|000 0000 0000 0000 0000 0000 0000 0000 //某个负数的补码 —规定 符号位 既充当符号位 又 充当数值位
1|000 0000 0000 0000 0000 0000 0000 0000 //负数
//负的0
//负数 -2,147,483,648

1|111 1111 1111 1111 1111 1111 1111 1111 //某个负数的补码
1|000 0000 0000 0000 0000 0000 0000 0001 //-1

unsigned short [0~2^16-1] //65536-1
signed short [-2^15 ~ +2^15-1] //-32768 ~ 32767

//–笔试题
unsigned short i = 0;

for (i = 0; i <= 65536; ++i)
{
printf(“i = %d\n”,i);
}

整型的溢出:(上/下溢出)
1111 1111 1111 1111

•               1
  

---

1 0000 0000 0000 0000

unsigned short i = 0;
i = i - 1;
printf(“i = %d\n”,i);

0000 0000 0000 0000

•               1
  

---

1 1111 1111 1111 1111

总结：
1.常量形式
2.变量形式

gnu 组织 —标准C的基础上做了一些扩展
gcc

int a,b,c,d; //一次性定义多个变量

int a;
int b;

3.数据类型
a.数据存储
字节序 (大端、小端)
数值的存储
(补码形式)
b.数据类型大小
c.考点
整型的溢出

浮点型:
1.常量形式
1.234
1.2e3 //科学计数法形式 //1.2*10^3
1.2E3 //e后面 可以是正数 或 负数 不能是小数

2.变量形式

float //单精度
double //双精度

3.数据类型
存储
6.25

step1: 将小数 转换为 二进制形式的小数
整数部分: (除2取余法)
0110
小数部分:(乘2取整法)
0.25 * 2 = 0.5 — 0
0.5 * 2 = 1 — 1
组合：
0110.01
step2:将二进制形式的小数，写成科学计数法形式
1234.56 —> 1.23456*10^3
110.01 —> 1.1001 * 2^2 //科学计数法形式

step3:按照 IEEE 754 标准 存放

  1位 符号位|8位-指数位|尾数位 
            |          |
 
	   0    |  2 + 127 |
	        | -127~128 |
		     1000 0001   1001 0000 0000 0000 0000 
			 
	   0100 0000 1100 1000 0000 0000 0000 0000
	    4     0   c   8      0   0    0    0	

练习:
-12.25

  1100.01 
  
  1.10001 * 2 ^ 3
  
  
  1|3+127| 
  
  
  1100 0001 0100 0100 0000 0000 0000 0000 
   c     1   4    4    0    0    0    0 

大小
float f = 1.23;

问题:

0.9 * 2 = 1.8 — 1
0.8 * 2 = 1.6 — 1
0.6 * 2 = 1.2 — 1
0.2 * 2 = 0.4 — 0
0.4 * 2 = 0.8 — 0
0.8 * 2 = 1.6 — 1

double 8字节

符号位|指数位|尾数位
| 11位|52位
+1023

float
符号位|指数位|尾数位
| 8 位|23位
+127

浮点数的比较问题
精度问题

统一精度

浮点常量的类型:

默认识别为double类型
0.9f //表示识别为 float类型
0.9L //L表示long double

整型常量:
说明类型
123L //long int
123LL //long long int
123UL //unsigned long int

字符型:
a b c

“tom”

t <—>0100101010
a <—>0101010
编码

ASCII //

字符数据:
存到计算机

a ---> 编码值 (数值) ---> 无符号的整数 

常量形式:
‘a’ //字符常量

变量:

char ch; //tiny int

unsigned char [0~2^8-1] //255
signed char [-128~127]

ascii表:
0~32 控制字符 不可见
‘0’~‘9’ //48~57
‘A’~‘Z’ //65~90
‘a’~‘z’ //97~122
‘0’ ----- 0
大小写转换
加减32

作业:
1.定义5个char变量
hello

转换成大写输出

画个流程图

提升之处:
1.
2.
3.

最大溢出 //向上
最小溢出 //向下

1.常量 |心得
2.变量
3.整型

作业:

1. 将hello 转换成大写输出

画个流程图

人的解决问题的思路 :
拿到 hello这些字符数据，减32

人类的思维 ---- 计算机的思维 ---- 编程语言表达出来

拿到 hello
这些字符数
据，减32

输入 —>[计算机处理] ---->输出

输入: //准备数据
处理数据
输出结果

//1.准备数据
定义5个char类型的变量
c1,c2,c3,c4,c5
//2.处理数据
-32
分别将c1,c2,c3,c4,c5
减32

//3.输出结果
打印结果

高内聚
低耦合

字符类型:
‘a’

变量:
char
unsigned char
signed char

---

字符数据存储
ASCII编码

‘\n’ //一个字符 转义字符

‘\n’ //换行

\n

“n”

总结：
1.常量 形式
‘a’
‘\141’
‘\x61’

97
0141
0x61

2.变量

char
unsigned char
signed char

3.要点
字符数据存储
ASCII表
转义字符

4.考点
‘abcd’ //多个字符
数字字符 与 数值之间 转换
字符大小写转换

运算符 表达式

算术运算
+

/
% 取余
++

运算符
表达式 由运算符 和 运算数 构成字符序列
1+2 //所有的表达式都是有结果的(值)
//表达式一定是由数据类型的

1+(23)
1+(23)

隐式类型转换

double <---- float




 
int <----char/short 

规则:
从右向左:
必转

从下到上:
低精度类型 与 高精度类型混合运算
此时 低精度 往 高精度转

-10

1|000 0000 0000 0000 0000 0000 0000 1010
1|111 1111 1111 1111 1111 1111 1111 0101
1111 1111 1111 1111 1111 1111 1111 0110
f f f f f f f 6

练习:
10+‘a’+1.5 — 8765.1234 *‘b’

10 + 'a' + 1.5 - (8765.1234 *'b')  //优先级 

(((10 + 'a') + 1.5) - (8765.1234 *'b') ) //结合性 

  10 + 'a'
  int  int

(double - double ) 	 
            double    double

表达式怎么看？
1.有哪些运算符?
2.运算符的
优先级
结合性

21、设有以下定义，并以赋予了确定的值：
char w; int x; float y; double z;
则表达式w*x+z-y所求得值的数据类型为______________。

(((w * x) + z )- y)
char * int
int * int => int
(double - double) //double

/ 除法
注意:
1.除数不能为0
2.整型数相除 — 相当于是整除

强制类型转换:
(类型)表达式

123.4578
123.4578
问题：
编译时的问题
错误 — 语法错误
警告 — 语法不合适
运行时的问题
逻辑问题 — 调整思维

%
注意：
1.浮点型不能做求余运算
2.求余运算 第二操作数 不能是 0
3.求余运算的结果的符号 取决于 左操作数的符号

有啥用?

a.判断奇数偶数?
a%2 ==?

b.a%N 结果 [0~N-1]
抽题的程序?

100道题 ? //0~99

随机除10道题?

随机数的产生

工具:
函数

   随机数产生的函数 
  
   伪 -- 假 
   int rand(void);//函数圆形 
   srand(int seed); //产生种子值
   time_t time(NULL);
   50~99之间  //后50道题

++ //自加
– //自减

i++ //先用(表达式的结果) 后加 i
++i //先加i,后用 (表达式的结果)

i++ //表达式的结果?

int i = 1;

int b = i++;

注意：

1. 浮点数也能自增自减
2. ++，–运算数 必须是左值 (变量)
3. 注意 尽量避免
   printf(“%d%d\n”,i,++i);
   不要写出这种不确定的代码

op.c: In function ‘main’:
op.c:82:4: error: lvalue required as increment operand
10++;
^~

lvalue (left value) //左值 — 能放在 = 左边的这些量

int a;
a = 10;

constant // 常量的意思

const
const int a = 10; //a 只读变量 —只能读 不能修改
左值 (lvalue – locationable) //可定位的 —能不能被定位到
&
表达式
匿名变量 //都是右值

i+++++i //贪心原则
从左到右逐个字符的扫描表达式，
看这些字符能否，尽可能多的结合成c的运算符
不能结合，就还是字符本身

i+++++i
i ++ ++ + i
i++ ++ +i
(((i++)++) + i)

赋值运算:

赋值运算表达式的的结果，就是左值获得的值的

int a;
a = 10;
(a=(b=(c=1)))

+=
-=
*= //赋值运算
a += 1 // a = (a + 1)

逗号运算: 顺序求值运算符
形式:
表达式1,表达式2, …,表达式n

逗号表达式的结果:
是最后一个表达式的结果

int i = 0;
int j = 0;
for (i = 1,j = 2;
{

}

总结:
1.数据类型
整型
浮点
字符

a.常量
b.变量
c.长度
d.考点
2.运算符 & 表达式
隐式类型转换
强制类型转换

运算
算术 > 赋值 > 逗号

/
%
++

unsigned char a[256]; //char [-128,127]

[0~255]