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  -> 可执行程序app

gcc hello.o -o app

gedit hello.c

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

(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

进制转换

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

2进制： 0，1

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

16进制：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

37

八进制开头：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

1.打印基本数据类型sizeof大小

2.利用vs2013学会查看内存， 查看变量地址和地址里的数值