进制编码

 

//十进制

//0 1 2 3 4 5 6 7 8 9 10 11 12 .... 99 100 101 ...

//进位: "逢十进一"

//二进制(对于计算机是最自然的语言)

//0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111

//"逢2进1"

//高电平: 1 低电平 0

//5+6

//机器语言

//0101001010101010

//0101001010101001

//1010101010100110

//汇编语言

//5+6

//movl $5 %-8(rbp)

//movl $6 %-12(rbp)

//movl %-8(rbp) %eax

//addl %-12(rbp) %eax

//movl %eax %esi

//可移植性差

//5+6 c99

//int a = 5;

//int b = 6;

//int c = a+b;

//简洁 , 可移植性强, 健壮性

//编译器:C语言 -- >  汇编语言 --> 二进制语言

//OC语言 --> C语言 --> 汇编语言 --> 二进制语言

//123 = 1*10^2 + 2*10^1 + 3*10^0

//除10倒序取余数

//123  / 10 -- 3

//12   / 10 -- 2

//1    / 10 -- 1

//123

//十进制转二进制

//除2倒序取余数

//123

//123 / 2 -- 1

//61  / 2 -- 1

//30  / 2 -- 0

//15  / 2 -- 1

//7   / 2 -- 1

//3   / 2 -- 1

//1   / 2 -- 1

//0   / 2 -- 0

//0

//123 = 0b1111011 = 1 *2^0 + 1*2^1 + 0*2^2 + 1*2^3 + 1*2^4 + 1*2^5 + 1*2^6 = 1 + 2 + 0 + 8 + 16 + 32 + 64 = 123

//表示二进制数在数据的前面加0b  0b1010101001 0b11111

//345 678 987

/*int main(int argc,const char *argv[])

{

    int bin[32]={};

    int num;

    scanf("%d", &num);//小写键盘Enter键不能使用

    //%d  整型数据格式化占位符

    int i=0;

    while (num) {//num = 0

        bin[i]= num%2;

        num/=2;//改变num的值

        i++;

    }

    printf("0b");

    for (i=i-1; i>=0 ; i--) {

        printf("%d", bin[i]);

    }

    printf(" ");

    

    return 0;

}*/

//八进制

//0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 ...

//逢8进1

//八进制在前面加0表示八进制数

//010

//数据的大小不因为进制的表现形式而改变

//int main(int argc, const char *argv[])

//{

//    int a = 10;

//    int b = 0b1010;

//    int c = 012;

//    int d = 0xa;

//    

//    printf("a = %d b = %d c = %d d = %d ", a, b, c, d);

//

//    return 0;

//}

//十进制数转八进制数

//除8倒序取余数

//123

//123  / 8 --- 3

//15   / 8 --- 7

//1    / 8 --- 1

//0

//123 = 0173 = 3*8^0 + 7*8^1 + 1*8^2 =  3 + 56 + 64 = 123

//233 156 78

//int main(int argc,const char *argv[])

//{

//    int num ;

//    scanf("%d", &num);

//    printf("0%o ", num);//%o 八进制数占位符

//    return 0;

//}

//八进制转二进制

//"421"

// 0     1     2      3      4      5       6      7

//000   001   010     011    100    101     110    111

//0173 = 0b1111011

//把八进制数中每一位, 分别用三位二进制数替换

//04567    0765   01234

//0b100 101 110 111

//0b111 110 101

//0b001 010 011 100

//二进制数转八进制数

//0b 011 110 001 101 011 110 000 110

//036153606

//从低位开始, 每三位为一组, 高位不足三位补0, 用八进制数替换三位二进制数

//十六进制

//逢十六进一

//0 1 2 3 4 5 6 7 8 9 a/A b/B c/C d/D e/E f/F

//10 11 12 13 .... 1f ...20 ...ff ...100 ...101

//前缀0x说明一个十六进制数 0x100

//十进制数转十六进制数

//除十六倒序取余数

//123

//123  / 16 -- b

//7    / 16 -- 7

//0

//123 = 0x7b = b*16^0 + 7*16^1 = 11+112 = 123;

//十六进制转二进制

//分别用4位二进制数替换每一位十六进制数

//"8421"

//0      1    2     3     4    5     6     7     8

//0000 0001 0010   0011  0100  0101  0110  0111  1000

//9      a       b      c     d     e      f

//1001   1010   1011   1100   1101  1110  1111

//0x2345678 = 0b10001101000101011001111000

//0xfeabc9876543210 = 0b1111 1110 1010 1011 1100 1001 1000 0111 0110 0101 0100 0011 0010 0001 0000

//二进制转十六进制

//从低位开始, 每四位为一组, 高位不足四位补0, 分别用十六进制数替换四位二进制数

//0b0101 1101 0110 1010 1111 0001 1110 1100

//0x5d6af1ec

//对于一个很大的数转换成二进制,用八进制或者十六进制进行过度

//345678908765

//计算机中的单位

//计算机中最小的单位是二进制位 1bit

//八个二进制位 组成一个字节 1Byte = 8bits

//1Kb = 1024Bytes

//1Mb = 1024Kb

//1Gb = 1024Mb

//1Tb = 1024Gb

//1Pb = 1024Tb

//硬盘厂商

//500Gb = 500*1000Mb = 500 * 1000Mb *1000Kb = 500 *1000Mb *1000Kb *1000Byte

//int main(int argc, const char * argv[]) {

//    

//    

//    printf("hello world ");

//

//    return 0;

//}

//数据在计算机中存储形式

//内存: RAM ROM

        //由二进制位电路组成

//数据编码方式

//以8bits为例   char

//以最高位作为符号位, 其余位表示数据的大小

//最高位为1 说明是一个负数, 最高位为0 说明是一个正数

//原码: 最高位为符号位, 其余位表示数据的绝对值大小

//-6 1000 0110

//6+5

//    00000110  6

//    00000101  5

//-------------------

//    00001011 = 11

//6+(-5)

//    0000 0110

//    1000 0101

//-----------------

//    1000 1011(原码) = -11

//原码不能进行减法运算, 原因是符号位也参与了运算

//反码: 正数的反码就是它的原码, 负数的反码,是在原码的基础上,符号位不变,其余位按位取反

//7 原码: 0000 0111 反码: 0000 0111

//-7  原码: 1000 0111 反码: 1111 1000

//-5 原码: 1000 0101 反码; 1111 1010

//-9 原码: 1000 1001 反码: 1111 0110

//-12 原码: 1000 1100   反码: 1111 0011

//6+(-5)

//    0000 0110

//  + 1111 1010

//----------------

//    0000 0000(反码) = 0

//-5+(-6)

//    1111 1010

//+   1111 1001

//-----------------

//    1111 0011(反码) ==> 1000 1100  ==> -12

//反码转原码: 再求一次反码

//0 的表示不唯一

//+0  0000 0000

//-0  1000 0000

//反码不能存储数据的原因就是0的表示不唯一

//补码: 正数的补码就是它的原码 负数的补码,是在反码的基础上加1

//6 : 0000 0110(补码)

//-6 : 1000 0110 --> 1111 1001 --> 1111 1010(补码)

//-5 : 1000 0101 --> 1111 1010 --> 1111 1011(补码)

// -6 + (-5)

//   1111 1010

//   1111 1011

//---------------

//   1111 0101(补码) --> 1000 1010 --> 1000 1011(原码) = -11

//补码转原码: 正数不变, 对于负数, 符号位不变, 其余位按位取反加1

//计算机中采用补码的方式存储数据

//-12 原码: 1000 1100 反码: 1111 0011 补码: 1111 0100

//-34 原码: 1010 0010 反码: 1101 1101 补码: 1101 1110

//-128 原码: 11000 0000  反码: 10111 1111 补码: 1000 0000

//规定: 1后面跟7个0就是当前范围内最小的数  1即表示符号位,又表示绝对值大小

//-127 原码: 1111 1111  反码: 1000 0000 补码: 1000 0001

//-0 原码: 1000 0000 反码: 1111 1111 补码: 0000 0000

//+0 0000 0000

//-128 ~~~ 127

//0x80 ~~ 0x7f

//16二进制位

//1000 0000 0000 0000   ~~~ 0111 1111 1111 1111

//0x8000  ~~~ 0x7fff

//数据类型

//整型

//有符号

//64位平台

//char     short      int       long       long long

//1byte    2bytes    4bytes     8bytes     8bytes

//32位平台

//1byte    2bytes     4bytes     4bytes    8bytes

//无符号

//unsigned char 0x00 ~~~ 0xff

//unsigned int   0x00000000 ~~~ 0xffffffff

//unsigned short  0x0000 ~~~ 0xffff

//unsigned long   0x0000000000000000 ~~~ 0xffffffffffffffff

//unsigned long long 0x0000000000000000 ~~~ 0xffffffffffffffff

/*int main(int argc, const char *argv[])

{

    //int a;

    printf("char = %lu ", sizeof(char));//sizeof运算符 求数据类型,或者变量占用内存空间大小

//    char a= 0x80, b = 0x7f;

//    printf("char %d ~~~ %d ", a, b);

    

    printf("unsigned char = %ld ", sizeof(unsigned char));

    //0 ~~ 255

//    unsigned char a= 0x00, b = 0xff;

//    printf("char %d ~~~ %d ", a, b);

//    short a =0x8000, b = 0x7fff;

//    printf("short  %d ~~~ %d ", a, b);

    

//    printf("short = %lu ", sizeof(short));

//    int a = 0x80000000, b = 0x7fffffff;

   // printf("int %d ~~~ %d ", a, b);

    

    printf("int = %lu ", sizeof(int));

    

    long a= 0x8000000000000000, b= 0x7fffffffffffffff;

    printf("long %ld ~~~ %ld " , a, b);

    

    printf("long = %lu ", sizeof(long));

    

    printf("long long = %lu ", sizeof(long long));

    

    return 0;

}

*/

//%d : char short int

//%ld : long

//%lld: long long

//%u: unsigned char unsigned short unsigned int

//%lu: unsigned long

//%llu: unsigned long long

//%x: 打印十六进制

//%o: 打印八进制

//int main(int argc,const char *argv[])

//{

//    long long a=789;

//    printf("a = %lld", a);

//    

//    unsigned int b=12;

//    printf("%u", b);

//    

//    return 0;

//}

//浮点类型

//单精度   双精度    长双精度

//float   double   long double

//4字节    8字节     16字节

//int main(int argc, const char *argv[])

//{

//    printf("float = %lu ", sizeof(float));

//    printf("double = %lu ", sizeof(double));

//    printf("long double = %lu ", sizeof(long double));

//    

//    return 0;

//}

//浮点类型数据表示

//3.14

//科学计数法: 5678.678 5.678678 * 10^3;(不能在计算机中表示)

//指数法: 34.56  ==> 3.456e1

//int main(int argc,const char *argv[])

//{

//    float f1 = 3.14;//常用方式

//    printf("%f ", f1);

//    float f2 = 3.456e1;//指数法

//    printf("%f ", f2);

//    float f3 = 3.45e-2;

//    printf("%f ", f3);

//    

//    return 0;

//}

//浮点类型数据在内存中存储形式

//3.145   --> 0.3145e1

//-32.56  -->-0.3256e2

//1.符号位 2.小数位 3. 指数位

//float 精度 6~7位

//double 精度 15~16位

int main(int argc,const char *argv[])

{

    float f1 = 567.2345434532345345;

    printf("%f ", f1);//%f

    double f2 = 6798.34567876543234567876;

    printf("%.20f ", f2);//%lf %f

    

    long double f3 = 34567.345678987654345678987654;

    printf("%Lf ", f3);//%Lf

    

    return 0;

}