C语言纪要

C语言笔记

程序编译链接原理

预处理： c -> i

gcc -E  hello.c -o hello.i

编译： i / c -> s

gcc -S hello.i -o hello.s

汇编： s -> o

gcc -c hello.s -o hello.o

链接：.o -> 可执行程序exe

gcc hello.o -o exe

大小端存储法

小端存储法——高地址存高字节，低地址存低字节（高存高，低存低）

(intel/ARM)

0x表示十六进制

数值：0x12 34 56 78在小端存储器里如何存储

0x8003 0x12

0x8002 0x34

0x8001 0x56

0x8000 0x78

1 byte = 8bit

大端存储法——高地址存低字节，低地址存高字节（高存低，低存高）

（IBM大型机/网络字节序）

数值：0x12 34 56 78在小端存储器如何存储

0x8003 0x78

0x8002 0x56

0x8001 0x34

0x8000 0x12

进制转换

十进制：0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

二进制：0, 1

八进制：0, 1, 2, 3, 4, 5, 6, 7

十六进制：0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F

百 十 个

1 2 3

1x10^2 + 2x10^1 + 3x10^0

0 1 0

0x2^2 + 1x2^1 + 0x2^0 = 2

1100 1010

0 + 2 + 0 + 8 + 64 + 128 = 202

|二进制： | 000 | 001 | 010 | 011 | 100 | 101 | 110 | 111 | 001000|

|十进制： | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

|八进制： | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 10|

二进制： 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

十进制： 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

十六进制： 0 1 2 3 4 5 6 7 8 9 A B C D E F

二进制：1010 0001 1000

十六进制：A 1 8

十六进制：3D7

二进制： 0011 1101 0111

八进制：11

二进制：001 001

八进制开头：0

十六进制开头：0x

十进制开头：什么都不跟

八进制：0777

十六进制：0xffff8000

5进制：23 = 3x5^0 + 2x5^1 = 13

|8 | 4 | 2 | 1|

|2^3 | 2^2 | 2^1 | 2^0|

|1000 | 0100 | 0010 | 0001|

0111

十进制：89 对应的二进制 1011001

89 …. 1

44 …. 0

22 …. 0

11 …. 1

5 …. 1

2 …. 0

1 …. 1

1011001

1+0+0+8+16+0+64 = 89

49 … 1

24 … 0

12 … 0

6 … 0

3 … 1

1 … 1

0011 0001

0x31

0567

101 110 111

bit位

8bit = 1byte =>每个字节拥有一个地址

0x8003

0x8002

0x8001

0x8000

1 和 -1

原码      反码      补码

1 0000 0001 0000 0001 0000 0001 正数的反码，补码都等于原码

-1 1000 0001 1111 1110 1111 1111 负数的补码等于把反码加1

0 0000 0000 0000 0000 0000 0000

-0 1000 0000 1111 1111 0000 0000

如果（0 等于 -0）

执行aaaa；

否则

执行bbbb；

97 =》 97 … 1 => 0110 0001

48 … 0

24 … 0

12 …. 0

6 … 0

3 … 1

1 … 1

原码 反码 补码

-31 => => 31 => 31 … 1 => 0001 1111 => 1001 1111 => 1110 0000 => 1110 0001

15 … 1

7 … 1

3 … 1

1 … 1

char b = 1; => (-128~127)

unsigned char a = 129; => (0~255)

s

0000 0000

1000 0001

1111 1111

int

unsigned int -> (0~2^32-1)

char b = ‘x’;

int c = 10;

‘x’ => 120 => 0111 1000

10 => 1010

.

.

.

0x8003

0x8002

0x8001

&b => 0x8000 1BYTE 0111 1000

.

.

.

0x7003 0000 0000 => 0x00

0x7002 0000 0000 => 0x00

0x7001 0000 0000 => 0x00

&c => 0x7000 0000 1010 => 0x0A

printf(“&c = %p\tc = %d”, &c, c);

‘x’ => 120

‘\a’

‘”’

345

“hello” => ‘h’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’

‘a’ == “a”

“a” = “c”;

“123” => 123

‘1’ ‘2’ ‘3’ ‘\0’

‘1’ - ‘0’ = 1

1*10 + ‘2’-‘0’ = 12

12*10 + ‘3’-‘0’ = 123

int a = 5;

a % 3 => 2

a / 2 => 2

float a = 5.0

a % 3 => ???报错

a / 2 => 2.5