C语言 进制关系

二进制：

            逢二进位 （ 0 1 ）

            在c代码里的二进制数以0b开头：

                0b1001  0b1111  0b11111001

                0b111111111111111111111111

十六进制：

            逢十六进位（ 0 1 2 3 4 5 6 7 8 9 a b c d e f )            在c代码里以0x开头表达16进制数

                0x1   0x1111 0xabcd 0x12ab 

                0xffaabbccddee11234456789

八进制：

            逢八进位  （0 1 2 3 4 5 6 7)

            在c代码里以0开头来表达八进制数

                012  01234567

                07654321 

十进制：        1234   ＝ 4*1 ＋ 3*10 ＋ 2*100 ＋ 1*1000

                     ＝4*10^0 + 3*10^1 + 2*10^2 + 1*10^3

                      = 1234

                    1234  %10  4  * 10^0  

            除10    123   %10  3  * 10^1

            除10    12    %10  2  * 10^2

            除10    1     %10  1  * 10^3

十进制转二进制：

                1234 -> 二进制

                 1234

            /2    617    余 0   * 2^0

            /2    308    余 1   * 2^1

            /2    154    余 0   * 2^2

            /2     77    余 0   ...

            /2     38    余 1

            /2     19    余 0

            /2      9    余 1

            /2      4    余 1

            /2      2    余 0

            /2      1    余 0

            /2      0    余 1

               1234  ->0b10011010010

十进制转十六进制：

                1234 -> 十六进制

                    1234

            /16     77    余 2

            /16     4     余 13 ->d

            /16     0     余 4

                1234  ->    0x4d2

十进制转八进制：

                1234 -> 八进制

                    1234

            /8       154    余  2

            /8        19    余  2

            /8         2    余  3

            /8         0    余  2

                1234 -> 02322

总结：十进制转n进制的方法：

                不断的除n，除到商为0止，余数倒序便可

二进制转十进制：

                0b11011001

                1 1 0 1 1 0 0 1

          幂    7 6 5 4 3 2 1 0

            1*2^0+0*2^1 + 0*2^2 + 1*2^3+1*2^4+0*2^5+1*2^6+            1*2^7 = 1+8 +16 +64+ 128 = 217 

十六进制转十进制：

                0x123 

                1  2   3

            幂  2  1   0

                3*16^0 + 2*16^1 + 1*16^2 =3+32+256=291

八进制转十进制：

                0123

                1 2 3

            幂  2 1 0

                3*8^0+2*8^1+1*8^2 = 3+16+64=83

二进制转十六进制：(8421规则)

                0b1101110010101            

              ->     0001  1011    1001   0101

                  幂 3210  3210    3210   3210

                     8421  8421    8421   8421

                       1     11     9      5

                       1      b     9      5

                -> 0x1b95

十六进制转二进制：(每一个十六进制位变成4个二进制位)  

                    0xabcd1234

                    a    b    c    d    1    2    3    4

            0b     1010 1011 1100 1101 0001 0010 0011 0100 

                0b10101011110011010001001000110100

二进制转八进制：（421规则）

                0b11010010010101

                 011 010 010 010 101

            幂   210 210 210 210 210

                 421 421 421 421 421

            ->    3   2   2   2   5

            -> 032225

八进制转二进制：(每一个八进制位变成3个二进制位)

                    01234

                      1    2    3    4

                ->   001  010  011  100

            ->      0b 1 010 011 100

                   ->     0b1010011100

二进制的加法：

                0b 1 1 0 1 0 1 1 1

            +   0b 0 1 1 0 1 0 1 0

            --------------------------

              0b 1 0 1 0 0 0 0 0 1

八进制的加法：

                0   1 2 3 4

                0   7 6 5 3

            -----------------

                  1 1 1 0 7

**********************************

原码  反码  补码

        

    概念：

        机器数：  11011010

            机器数就是一种内存状态,即一种二进制状态,不能

            读成咱们数学意义上的数值

        真值：    有一个机器数11011010

                有符号的真值的表达方式：

                最高位的概念：

                            若是是1字节的数据，

                                第7位就是最高位

                            若是是2字节的数据

                                第15位就是最高位

                            若是是4字节的数据

                                第31位就是最高位

                            若是是8字节的数据

                                第63位就是最高位

                    最高位表明符号位  

                    最高位为1表明负数

                    最高位为0表明正数

                10011000   有符号表达一个真值：-24

                无符号的真值的表达方式：

                    直接将机器数当作二进制数转成十进制便可

                例：

                    10011000 -> 128+24= 152  

    原码：  

            正数的原码 就是将它转成二进制数便可,

            本质是(机器数,是一种二进制状态)

            负数的原码: 最高位为符号位 剩下的位表明数值

            例：

                1字节的数-25  的原码(的机器数)：10011001 

                1字节的数25   的原码(的机器数): 00011001

                2字节的数-25  的原码(........): 

                              1000000000011001

                2字节的数25   的原码：

                              0000000000011001

    反码：  正数的反码等于原码

            负数的反码是在原码的基础上，符号位不变，其他

            位取反

                1字节的数-25  的反码:

                    (原)10011001 ->  (反)11100110

                1字节的数25   的反码：

                    (原)00011001 ->  (反)00011001

                2字节的数-25  的反码：

                    (原)1000000000011001

                  ->(反)1111111111100110

    补码：

            正数的补码等于原码

            负数的补码是在原码的基础上，符号位不变，其他

            位取反后+1 

                1字节的数-25 的补码：

                    (原)10011001

                 -> (反)11100110

                 -> (补)11100111

                2字节的数-25 的补码:

                    (原)1000000000011001

                  ->(反)1111111111100110

                  ->(补)1111111111100111

为何要学习补码：

        

        假设拿原码作加法运算：

                25  00011001

            +  -24  10011000

        -----------------------

                    10110001  = -49

        用原码参加运算会发生错误

        因此用补码试试：

                25  00011001

               - 4  11111100

            -------------------

                    00010101

*************************************

数据类型  变量   内存    

            char c=-114;

            unsigned char uc=142; 

            上边这两个变量的内存状态彻底同样

        

    数据类型的概念：

            是一种规则，这种规则可以知道访问内存时须要

            访问几个字节， 同时也能知道将内存里的状态以

            什么样的表达方式表达出来

    变量的概念：

            参照一种规则(数据类型),对某一个内存地址打上

            一个标签，划定一个大小，有这种变量以后，程序

            处理数据时就能够经过变量名来访问内存

    

    数据类型分类： 

                    标量类型： 整型  浮点型, 指针，  

                    聚合类型： 数组和结构体

        学习某种数据类型时：

                        讨论该数据类型的变量的三个属性：

                            值， 地址，  内存大小

                        数组类型：

                            元素， 地址， 内存大小

                        结构体：

                            成员   地址   内存大小

            

            整型变量：

                         有符号      无符号

                 1 字节  char        unsigned char

                 2 字节  short (int) unsigned short

                 4 字节  int         unsigned int

                 8 字节  long        unsigned long

                 8 字节  long long   unsigned long long

           

           printf这个函数的格式控制：

                int a;

                printf(" %d ", a);  以有符号整型输出4个字节

                printf(" %p ", &a); 以16进制输出8个字节

                long l;

                printf(" %ld ",l ); 以有符号整型输出8个字节

                unsigned long ul;

                printf(" %lu ",ul); 以无符号整型输出8个字节

                char c;

                printf(" %d ",c); 将单字节整型以有符号整型4字节输出

                printf(" %c ",c); 将单字节整型以字符形式输出

                printf(" %x ",a); 以16进制输出4个字节

                讨论一下各类长度的整型变量的取值范围 

                  char            [-128, 127]

                  unsigned char   [0 ,   255]

                  short int       [-2^15 ,2^15-1]

                  unsigned short  [0 ,   2^16-1]

                  int             [-2^31, 2^31-1]

                  unsigned int    [0,  2^32-1]

                  long            [-2^63, 2^63-1]

                  unsigned long   [0,   2^64-1]

       

       浮点型变量：

                    float   4个字节

                            精确到小数点后6位

                            printf("%f",f); %f输出6位小数

                    double  8个字节

                            精确到小数点后12位

                            printf("%1.12f",f); %1.12f输

                            出12位小数,1位整数

        

          数据类型之间隐式转换的原则：

                相同数据类型之间：只能从小内存往大内存转

                整型与浮点型之间：整型能够转浮点型

                                  但浮点不能转整型