精华内容
下载资源
问答
  • 补码  计算机是按照补码的形式存数字的。int32位补码形式的最大值2^31-1,最小值-2^31。...二进制小数部分转化为十进制时,权值的为负次幂。 十进制小数部分转化为二进制时,乘2取整。
    • 补码

     计算机是按照补码的形式存数字的。int32位补码形式的最大值2^31-1,最小值-2^31。

    1. 如果是011111...1111一共31个1,正数的补码还是他本身,所以最大值是2^31-1

    2. 如果是11111..111一共32个1,第一个1表示负号,其补码形式是符号位不变,数值部分取反加1,得10000000...00其中31个0,这个数是2^31,其中有个-1号,所以是-2^31.(附加部分有详细操作)

    • 补充1000...000其中31个0,不是0的补码,而是1111...111其中32个1的补码,0的补码是000...000包含32个0

    • 原码

    原码就没什么可说的了。就是起始位有个0或1表示正负号,剩下的是数值部分。

    • 反码 

    反码实在原码基础上操作的,符号位不变,数值部分取反即可得到反码(附加部分有详细操作)。

    • 附加

    1. 一个正整数,当用原码,反码,补码表示时,符号位都固定为1,用二进制表示的数位值都相同,即三种表示方法都一样。

    2. 一个负数,当用原码,反码,补码表示时,符号位都固定为1,用二进制表示的数位都不相同。此时由原码表示法变成补码表示法规则如下

    •  原码符号位1不变,整数的每一位二进制数位求反得到反码

    •  反码符号位为1不变,反码数值位最低位加1,得到补码。

    •  进制转化 

    • 二进制小数部分转化为十进制时,权值的为负次幂。
    • 十进制小数部分转化为二进制时,乘2取整。

    展开全文
  • 十进制转换为二进制,分为整数部分和小数部分。 整数部分采用除2倒取余法,具体做法:用2去除十进制整数,可以得到一个商和余数;在用2去除商,又会得到一个商和余数,如此进行,知道商为0时为止,然后把先的到的...

    d8de9f64994f4b9ebc1768fddcb3a17e.png

    一、十进制与二进制的相互转换

    1. 十进制转换为二进制,分为整数部分和小数部分。

    整数部分采用除2倒取余法,具体做法:用2去除十进制整数,可以得到一个商和余数;在用2去除商,又会得到一个商和余数,如此进行,知道商为0时为止,然后把先的到的余数作为二进制的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。 小数部分采用乘2取整法,具体做法:用2乘十进制小数,可以得到积,将积中的整数部分取出,在用2乘余下的小数部分,又得到一个积,在将积中的整数部分取出,如此进行,直到积中的小数部分为0,此时0或1为二进制的最后一位,或者达到所要求的精度为止,然后把取出的整数部分按顺序排列起来,先取得整数作为二进制小数的最高位有效位,后取的整数作为低位有效位。

    2. 二进制转换为十进制,方法:按权相加法,即将二进制每位上的数乘以权,然后相加之和即是十进制数。


    二、预备知识

    由于计算机的硬件决定,任何存储于计算机中的数据,其本质都是以二进制码存储

    根据冯·诺依曼提出的经典计算机体系结构框架,一台计算机由运算器、控制器、存储器、输入和输出设备组成。其中运算器只有加法运算器,没有减法运算器(据说一开始是有的,后来由于减法运算器硬件开销太大,被废了)。

    所以计算机中没办法直接做减法的,它的减法是通过加法实现的。现实世界中所有的减法也可以当成加法的,减去一个数可以看作加上这个数的相反数,但前提是要先有负数的概念,这就是为什么不得不引入一个符号位。符号位在内存中存放的最左边一位,如果该位位0,则说明该数为正;若为1,则说明该数为负。

    而且从硬件的角度上看,只有正数加负数才算减法,正数与正数相加,负数与负数相加,其实都可以通过加法器直接相加。

    原码、反码、补码的产生过程就是为了解决计算机做减法和引入符号位的问题。


    三、原码

    原码:是最简单的机器数表示法,用最高位表示符号位,其他位存放该数的二进制的绝对值

    以带符号位的四位二进制数为例:1010,最高位为1表示这是一个负数,其它三位010,即0*2^2+1*2^1+0*2^0=2,所以1010表示十进制数-2。

    edc5a3a871ed2bea1d2f703a1ccf90a3.png
    部分正负数的二进制原码表示

    原码的表示法很简单,虽然出现了+0和-0,但是直观易懂。于是开始运算——

    0001+0010=0011,1+2=3;
    0000+1000=1000,+0+(-0)=-0;
    0001+1001=1010,1+(-1)=-2。

    于是可以看到其实正数之间的加法通常是不会出错的,因为它就是一个很简单的二进制加法,而正数与负数相加,或负数与负数相加,就要引起莫名其妙的结果,这都是符号位引起的。0分为+0和-0也是因它而起。

    原码的特点:

    1. 原码表示直观、易懂,与真值转换容易。

    2. 原码中0有两种不同的表示形式,给使用带来了不便。

    通常0的原码用+0表示,若在计算过程中出现了-0,则需要用硬件将-0变成+0。

    3. 原码表示加减运算复杂。

    利用原码进行两数相加运算时,首先要判别两数符号,若同号则做加法,若异号则做减法。在利用原码进行两数相减运算时,不仅要判别两数符号,使得同号相减,异号相加;还要判别两数绝对值的大小,用绝对值大的数减去绝对值小的数,取绝对值大的数的符号为结果的符号。可见,原码表示不便于实现加减运算。

    四、反码

    原码最大的问题就在于一个数加上它的相反数不等于0,于是反码的设计思想就是冲着解决这一点,既然一个负数是一个正数的相反数,那干脆用一个正数按位取反来表示负数。

    反码:正数的反码还是等于原码;负数的反码就是它的原码除符号位外,按位取反

    以带符号位的四位二进制数为例:3是正数,反码与原码相同,则可以表示为0011;-3的原码是1011,符号位保持不变,低三位按位取反,所以-3的反码为1100。

    206b22e2345591c447280739fbc274b9.png
    部分正负数的二进制反码表示

    再试着用反码的方式解决一下原码的问题——

    0001+1110=1111,1+(-1)=-0;
    1110+1100=1010,(-1)+(-3)=-5。

    互为相反数相加等于0,虽然的到的结果是1111也就是-0。但是两个负数相加的出错了。

    反码的特点:

    1. 在反码表示中,用符号位表示数值的正负,形式与原码表示相同,即0为正;1为负。
    2. 在反码表示中,数值0有两种表示方法。
    3. 反码的表示范围与原码的表示范围相同。

    反码表示在计算机中往往作为数码变换的中间环节。


    五、补码

    补码:正数的补码等于它的原码;负数的补码等于反码+1(这只是一种算补码的方式,多数书对于补码就是这句话)。

    其实负数的补码等于反码+1只是补码的求法,而不是补码的定义,很多人以为求补码就要先求反码,其实并不是,那些计算机学家并不会心血来潮的把反码+1就定义为补码,只不过补码正好就等于反码+1而已。

    如果有兴趣了解补码的严格说法,建议可以看一下《计算机组成原理》,它会用“模”和“同余”的概念,严谨地解释补码。


    六、补码的思想

    补码的思想,第一次见可能会觉得很绕,但是如果肯停下来仔细想想,绝对会觉得非常美妙。

    补码的思想其实就是来自于生活,只是我们没注意到而已,如时钟、经纬度、《易经》里的八卦等。补码的思想其实就类似于生活中的时钟

    如果说现在时针现在停在10点钟,那么什么时候会停在八点钟呢?

    简单,过去隔两个小时的时候是八点钟,未来过十个小时的时候也是八点钟。
    也就是说时间倒拨2小时,或正拨10小时都是八点钟。
    也就是10-2=8,而且10+10=8。
    这个时候满12,说明时针在走第二圈,又走了8小时,所以时针正好又停在八点钟。

    所以12在时钟运算中,称之为模,超过了12就会重新从1开始算了。

    也就是说,10-2和10+10从另一个角度来看是等效的,它都使时针指向了八点钟。

    既然是等效的,那么在时钟运算中,减去一个数,其实就相当于加上另外一个数(这个数与减数相加正好等于12,也称为同余数),这就是补码所谓运算思想的生活例子。

    在这里,再次强调原码、反码、补码的引入是为了解决做减法的问题。在原码、反码表示法中,我们把减法化为加法的思维是减去一个数等于加上这个数的相反数,结果发现引入符号位,却因为符号位造成了各种意想不到的问题。

    但是从上面的例子中,可以看到其实减去一个数,对于数值有限制、有溢出的运算(模运算)来说,其实也相当于加上这个数的同余数。

    也就是说,不引入负数的概念,就可以把减法当成加法来算。


    七、补码的实例

    接下来就做一做四位二进制数的减法(先不引入符号位)。

    0110-0010,6-2=4,但是由于计算机中没有减法器,没法算。

    这时候,想想时钟运算中,减去一个数,是可以等同于加上另外一个正数(同余数),这个数与减数相加正好等于模。

    也就是四位二进制数最大容量是多少?其实就是2^4=16(10000)。

    那么2的同余数,就等于10000-0010=1110,16-2=14。

    既然如此,0110-0010=0110+1110=10100,6-2=6+14=20。

    按照这种算法得出的结果是10100,但是对于四位二进制数最大只能存放4位,如果低四位正好是0100,正好是想要的结果,至于最高位的1,计算机会把它放入psw寄存器进位位中,8位机会放在cy中,x86会放在cf中,这里不做讨论。

    这个时候,再想想在四位二进制数中,减去2就相当于加上它的同余数(至于它们为什么同余,还是建议看《计算机组成原理》)。

    但是减去2,从另一个角度来说,也是加上-2,即加上-2和加上14得到的二进制结果除了进位位,结果是一样的。如果我们把1110的最高位看作符号位后就是-2的补码,这可能也是为什么负数的符号位是1,而不是0

    a956c8299d365f83efda3260e414adff.png
    部分正负数的二进制补码表示

    到这里,原码、反码的问题,补码基本解决了。

    在补码中也不存在-0了,因为1000表示-8。

    补码的特点:

    1. 在补码表示中,用符号位表示数值的正负,形式与原码的表示相同,即0为正,1为负。但补码的符号可以看做是数值的一部分参加运算。

    正数的补码表示就是其本身,负数的补码表示的实质是把负数映像到正值区域,因此加上一个负数或减去一个正数可以用加上另一个数(负数或减数对应的补码)来代替。
    从补码表示的符号看,补码中符号位的值代表了数的正确符号,0表示正数,1表示负数;而从映像值来看,符号位的值是映像值的一个数位,因此在补码运算中,符号位可以与数值位一起参加运算。

    2. 在补码表示中,数值0只有一种表示方法。

    3. 负数补码的表示范围比负数原码的表示范围略宽。纯小数的补码可以表示到-1,纯整数的补码可以表示到-2^n。

    由于补码表示中的符号位可以与数值位一起参加运算,并且可以将减法转换为加法进行运算,简化了运算过程,因此计算机中均采用补码进行加减运算


    八、为什么负数的补码的求法是反码+1

    因为负数的反码加上这个负数的绝对值正好等于1111,在加1,就是10000,也就是四位二进数的模,而负数的补码是它的绝对值的同余数,可以通过模减去负数的绝对值得到它的补码,所以负数的补码就是它的反码+1。

    相关文档:计算机组成原理

    展开全文
  • 2.对十进制转二进制完全char化,对二进制没有长度限制,只对十进制数有限制,只需要把int类型改成longlong类型就可以进一步扩大。 3.可以自定义输出的位长,为以后的调用做好准备。 #include <stdio.h> #...

    对上篇文章进行了改进,主要在
    1.通过结构体把函数集成度变高
    2.对十进制转二进制完全char化,对二进制没有长度限制,只对十进制数有限制,只需要把int类型改成longlong类型就可以进一步扩大。
    3.可以自定义输出的位长,为以后的调用做好准备。

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define MAXSIZE 64
    /***目前的实现思路:
    输入十进制整数或真小数及其需要的位数
    用函数分别输出其补码、反码 、移码
    ***/
    typedef struct rational_number{
        char charnum[MAXSIZE];//输入数用char表示
        long long integer;//输入数的整数部分
        double decimal;//输入数的小数部分(浮点数)
        double approximate;//输入的数的近似浮点数
    }Rational;
    
    typedef struct all_kinds_of_code{
        char* truecode;//原码
        char* reversecode;//反码
        char* modecode;//补码
        char* parallelcode;//移码
    }Allcode;
    
    char* bin_plus_bin(char* A, char* B);
    char* bin_to_codes(int num,int bit);
    
    //有理数扫描
    Rational* scan_rational(){
        Rational* num=(Rational*)malloc(sizeof(Rational));
        char c;
        int flag=0;//触发器,整数部分=0,小数部分=1
        int i=0;//全局char指针
        int weight=10;//表示小数部分的权重
        int negtive=1;//表示正负数
        //初始化
        num->integer=0;
        num->decimal=0;
        num->approximate=0;
    
        while((c=getchar())!='\n'){
            num->charnum[i++]=c;
            if(c=='-'){
                negtive=-1;
                continue;
            }
            if(c=='.'){
                flag=1;
                continue;
            }
            if(flag==0){
                num->integer=(num->integer)*10+c-'0';
                num->approximate=(num->approximate)*10+c-'0';
            }else{
                num->decimal+=(float)(c-'0')/weight;
                num->approximate+=(float)(c-'0')/weight;
                weight*=10;
            }
        }
        num->charnum[i]='\0';
        num->integer*=negtive;
        num->approximate*=negtive;
        num->decimal*=negtive;
        return num;
    }
    
    //给Allcode格式每个码统一输入某个值
    void send_to_Allcode(char c,int digit, Allcode* codes){
        codes->truecode[digit]=c;
        codes->reversecode[digit]=c;
        codes->modecode[digit]=c;
        codes->parallelcode[digit]=c;
    }
    
    //对Allcode格式输出
    void print_Allcode(Allcode* codes){
        printf("原码:%s  |",codes->truecode);
        printf("反码:%s  |",codes->reversecode);
        printf("补码:%s  |",codes->modecode);
        printf("移码:%s  \n",codes->parallelcode);
    }
    
    //对二进制字符串某位置反
    void reverse_digit(char* code, int digit){
        if(code[digit]=='0'){
            code[digit]='1';
        }else if(code[digit]=='1'){
            code[digit]='0';
        }
    }
    
    
    
    //十进制 (真)小数分别输出其补码、反码 、移码
    Allcode* dec_to_codes(double num,int bit){
        Allcode* codes=(Allcode*)malloc(sizeof(Allcode));
        codes->truecode=(char*)malloc((bit+2)*sizeof(char));
        codes->reversecode=(char*)malloc((bit+2)*sizeof(char));
        codes->modecode=(char*)malloc((bit+2)*sizeof(char));
        codes->parallelcode=(char*)malloc((bit+2)*sizeof(char));//第1位:. 最后一位:'\0'
    
        //最前面0 1 位及最后一位处理
        if(num>=1){
            printf("需要真小数\n");
            return -1;
        }else if(num<0){
            send_to_Allcode('1',0,codes);
            num*=-1;
        }else{
            send_to_Allcode('0',0,codes);
        }
        send_to_Allcode('.',1,codes);
        send_to_Allcode('\0',bit+1,codes);
    
        //生成原码(也是后面所有码的基础)
        int i=2;
        while(i<bit){
            num*=2;
            if(num>=1){
                send_to_Allcode('1',i++,codes);
                num-=1;
            }else{
                send_to_Allcode('0',i++,codes);
            }
        }
    
        //生成反码(也是补码和移码的基础)
        if(codes->truecode[0]=='1'){
            for(int i=2;i<bit;i++){
                reverse_digit(codes->reversecode,i);
                reverse_digit(codes->modecode,i);
                reverse_digit(codes->parallelcode,i);
            }
        }
    
        //生成补码(也是移码的基础)
        char* one="1";
        if(codes->truecode[0]=='1'){
            codes->modecode=bin_plus_bin(codes->modecode,one);
            codes->parallelcode=bin_plus_bin(codes->modecode,one);
        }
    
        //生成移码
        if(codes->truecode[0]=='0'){
            codes->parallelcode[0]='1';
        }else{
            codes->parallelcode[0]='0';
        }
    
        print_Allcode(codes);
    
        return codes;
    }
    
    //十进制 整数分别输出其补码、反码 、移码
    char* bin_to_codes(int num,int bit){
        Allcode* codes=(Allcode*)malloc(sizeof(Allcode));
        codes->truecode=(char*)malloc((bit+1)*sizeof(char));
        codes->reversecode=(char*)malloc((bit+1)*sizeof(char));
        codes->modecode=(char*)malloc((bit+1)*sizeof(char));
        codes->parallelcode=(char*)malloc((bit+1)*sizeof(char));//最后一位:'\0'
    
        //最前面0位及最后一位处理
        if(num>=0){
            send_to_Allcode('0',0,codes);
        }else{
            send_to_Allcode('1',0,codes);
            num*=-1;
        }
        send_to_Allcode('\0',bit,codes);
    
    
        //生成原码(也是后面所有码的基础)
        for(int i=bit-1;i>0;i--){
            send_to_Allcode(num%2+'0',i,codes);
            num/=2;
        }
    
        //生成反码(也是补码和移码的基础)
    
        if(codes->truecode[0]=='1'){
            for(int i=1;i<bit;i++){
                reverse_digit(codes->reversecode,i);
                reverse_digit(codes->modecode,i);
                reverse_digit(codes->parallelcode,i);
            }
        }
    
        //生成补码(也是移码的基础)
        char* one="1";
        if(codes->truecode[0]=='1'){
            codes->modecode=bin_plus_bin(codes->modecode,one);
            codes->parallelcode=bin_plus_bin(codes->modecode,one);
        }
    
        //生成移码
        if(codes->truecode[0]=='0'){
            codes->parallelcode[0]='1';
        }else{
            codes->parallelcode[0]='0';
        }
    
        print_Allcode(codes);
    
        return codes;
    }
    //二进制加法(不适用整数与小数混加)
    char* bin_plus_bin(char* A, char* B){
        int len=strlen(A);
        if(len<strlen(B)){
            len=strlen(B);
        }
        char* res=malloc((len+1)*sizeof(char));
        res[len]='\0';
        int flag=0;
        int ri=len-1;
        int ai=strlen(A)-1;
        int bi=strlen(B)-1;
        do{
            if(A[ai]=='.'){
                res[ri--]='.';
                ai--;
                continue;
            }
            if(B[bi]=='.'){
                res[ri--]='.';
                bi--;
                continue;
            }
            if(ai==-1){
                if(flag==1){
                    if(B[bi]=='1'){
                        res[ri--]='0';
                        bi--;
                    }else{
                        res[ri--]='1';
                        bi--;
                        flag=0;
                    }
                }else{
                    res[ri--]=B[bi--];
                }
                continue;
            }
            if(bi==-1){
                if(flag==1){
                    if(A[ai]=='1'){
                        res[ri--]='0';
                        ai--;
                    }else{
                        res[ri--]='1';
                        ai--;
                        flag=0;
                    }
                }else{
                    res[ri--]=A[ai--];
                }
                continue;
            }
            if(A[ai]!=B[bi]){//一个是1一个是0
                if(flag==0){
                    res[ri--]='1';
                    ai--;
                    bi--;
                    continue;
                }else{
                    res[ri--]='0';
                    ai--;
                    bi--;
                    continue;
                }
            }
            if(A[ai]==B[bi]){
                if(A[ai]=='0'){
                    if(flag==0){
                        res[ri--]='0';
                        ai--;
                        bi--;
                        continue;
                    }else{
                        res[ri--]='1';
                        flag=0;
                        ai--;
                        bi--;
                        continue;
                    }
                }else if(A[ai]=='1'){
                    if(flag==0){
                        res[ri--]='0';
                        flag=1;
                        ai--;
                        bi--;
                        continue;
                    }else{
                        res[ri--]='1';
                        ai--;
                        bi--;
                        continue;
                    }
                }
            }
        }while(ri>-1);
        return res;
    }
    
    int main()
    {
        Rational* num;
        int bit=32;
        while(1){
            num=scan_rational();
            if(num->decimal==0){
                //按整形处理
                printf("> 输入数:%d\n",num->integer);
                bin_to_codes(num->integer,bit);
                printf("> 输入数:%d\n",-1*num->integer);
                bin_to_codes(-1*num->integer,bit);
                printf("-------\n");
            }else if(num->integer==0){
                //按小数型处理
                printf("> 输入数:%f\n",num->decimal);
                dec_to_codes(num->decimal,bit);
                printf("> 输入数:%f\n",-1*num->decimal);
                dec_to_codes(-1*num->decimal,bit);
                printf("-------\n");
            }else{
                printf("暂时无法处理该类型\n");
                printf("-------\n");
            }
        }
    
    }
    
    
    展开全文
  • 二进制数据的表示方法2.1 有符号数与无符号数2.2 二进制的补码表示法2.3 二进制反码表示法2.4 小数二进制补码表示三.二进制的运算3.1 定点数与浮点数3.1.1 定点数的表示方法3.1.2 浮点数的表示方法3.1.3 定点数...

    一.进制运算的基本知识

    1.1 进制概述

    • 进位制是一种计数方式,亦称进位计数法或位置计数法
    • 有限种数字符号来表示无限的数值
    • 使用的数字符号的数目称为这种进位制的基数或底数(比如:使用的数字符号的数目为10[0-9],即为十进制)

    计算机因为有高低电平两种形式,所以非常适合二进制这种形式,但是有些情况使用二进制表达太冗长了,可以使用大进制位编码二进制位来解决这个问题,八进制、十六进制满足2的n次方的要求,所以在计算机中也经常使用八进制和十六进制表达特定内容。

    1.2 进制运算的基础

    如下图所示:N为正整数,dx为N的自右向左的第x-1位,r为基数
    在这里插入图片描述
    二进制转换十进制:按权展开法
    按权展开法与上图类似

    • 整数:N=(01100101)=1×26+1×25+1×22+1=101
    • 小数:N=(0.11001)=1×2-1+1×2-2+1×2-5=25/32

    十进制转换为二进制:整数——重复相除法;小数——重复相乘法

    • 整数
      取余数自底向上N=101=(01100101)
    重复除以2 得商 取余
    101/2 50 1
    50/2 25 0
    25/2 12 1
    12/2 6 0
    6/2 3 0
    3/2 1 1
    1/2 0 1
    • 小数
      取余数自上向下N=25/32=(0.11001)
    重复乘以2 得积 取整
    25/32 50/32=1+9/16 1
    9/16 18/16=1+1/8 1
    1/4 1/4=0+1/2 0
    1/4 1/2=0+1/2 0
    1/2 1=1+0 1

    二.二进制数据的表示方法

    2.1 有符号数与无符号数

    使用0表示正数,使用1表示负数,把符号位放在数字位最前面。 这就是原码表示法,上文所介绍的转换方法也是针对原码而言。

    原码表示法

    • 优点:表达简单明了,是人类最容易理解的表示方法
    • 缺点:0有两种表是方法(00、10)有歧义;进行异号数运算时非常复杂

    对于原码的缺点,我们希望有一种表示方法可以用正数代替负数;希望找到不同符号操作数更加简单的运算方法;希望可以使用加法操作代替剑法操作。

    2.2 二进制的补码表示法

    n表示x的位数
    补码表示方法
    例:x=-13的补码
    第一步:原码 x=1,1101
    第二步:补码 x=24+1-13=100000-1101=1,0011
    实现了正数替代负数,但计算补码的过程还是使用了减法。

    2.3 二进制的反码表示法

    反码的目的是找出原码和补码之间的规律,消除转换过程中的减法。

    规律:负数的反码等于原码除符号位外按位取反,负数的补码+1。

    2.4 小数的二进制补码表示

    二进制小数的补码
    例:x=-11/32的补码
    原码:x=1,0.01011
    反码:x=1,1.10100
    补码:x=1,1.10101
    规律:负数的反码等于原码除符号位外按位取反,负数的补码+1。

    三.二进制的运算

    3.1 定点数与浮点数

    3.1.1 定点数的表示方法

    小数点固定在某个位置的数称之为定点数。表示纯小数时候,把小数点放在符号位与数值位之间;表示纯整数时候,把小数点放在符号位和数值位之后;表示既非纯整数又非纯小数时候,则应乘以比例因子(小数点左移、右移几位)以满足定点数保存格式。

    3.1.2 浮点数的表示方法

    为什么引入浮点数?
    计算机处理的很大程度上不是纯小数或纯整数;数据范围很大,定点数难以表达。

    • 表示格式:N=S×rj,S——尾数,r——基数,j——阶码
      表示格式

    • 表示范围:假设阶码数值取m位,尾数数值取n位
      在这里插入图片描述

    • 单精度浮点数:使用4字节、32位来表达浮点数(float)

    • 双精度浮点数:使用8字节、64位来表达浮点数(double)

    • 浮点数的规格化:尾数规定使用纯小数;尾数最高位必须是1

    例:设浮点数字长为16位,阶码位5位,尾数为11位,将十进制数 -54 表示位二进制浮点数
    原码:x=1,110110
    浮点数规格化:x=-0.110110×2110

    阶码符号位 阶码数值位 尾数符号位 尾数数值位
    0 0110 1 0010100000

    注:尾数因为是纯小数补0要在尾部补,而且尾数要变为补码。

    3.1.3 定点数与浮点数的对比

    • 当定点数与浮点数位数相同时,浮点数表示的范围更大
    • 当浮点数位数为规格化数时,浮点数的精度更高
    • 浮点数运算包含阶码和尾数,浮点数的运算更为复杂
    • 浮点数在数的表示范围、精度、溢出处理、编程等方面均优于定点数
    • 浮点数在数的运算规则、运算速度、硬件成本方面不如定点数

    3.2 定点数的加减法运算

    3.3 浮点数的加减法运算

    3.4 浮点数的乘除法运算

    展开全文
  • 不能体现补码的取值范围与反码不同的特点。 本代码在code::blocks17.12中正常运行 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 64 typedef struct rational_number{ char charnum[MAXSIZE...
  • 首先,什么是反码,补码 原码 (1) 原码:在数值前直接加一符号位的表示法。 例如: 符号位 数值位 [+7]原= 0 0000111 B ...注意:a....定点小数表示方法 ...b. 8位二进制原码的表示范围:-12
  • 原码表示法是机器数的一种简单的表示法。其符号位用0表示正号,用:表示负号,数值一般用二进制形式表示。设有一数为x,则原码表示可记作〔x〕原。 例如,X1= +1010110 ...当用8位二进制来表示小数原码时,
  • 2.1 为了不累赘描述,本文以百度的二进制小数转换为十进制小数为例,如下图 2.2 十进制整数转二进制整数以及十进制小数转换为二进制小数如下 3. 原码、反码和补码 在理解二进制和十进制转换后,对于一个...
  • 各种进制之间的相互转换...二进制 逢二进一 八进制 逢八进一 十六进制 逢十六进一 十进制—>二/八/十六进制 口诀 整数部分,除2/8/16取余; 小数部分,乘2/8/16取整 例:23.25转换成二进制为10111.01 二...
  • 十进制(小数)转换为二进制(8位): 原码:首位是符号位,其余的n-1位表示数值的绝对值,数位不够用0补足。数值0的原码有两种形式:[+0] 原=00000000, [-0]原=10000000。 正数的原码、反码、补码都一致。 ...
  • - 整数型(不带小数的数字):byte,short,int,long ,分别占用字节1,2,4,8个字节 - 浮点型(带小数的数字):float,double ,区别是占用内存大小不一样分别是4,8字节 - 布尔型(真和假):boolean 占用1个字节 -...
  • 对于初学者,迟早要面对进制的转换,或许
  • 8位二进制的数转为10进制:  正数:  比如1,一定要转为00000001(原码),高位是0(补码等于原码),直接计算得十进制1,  负数:  比如11111111(原码),最高位是1,表示负数;符号位不变其他位取反再加...
  • 二进制数的补码及运算

    万次阅读 多人点赞 2019-04-22 12:00:47
    二进制进制小数部分的转化 1.正数的补码表示 正数的补码 = 原码 负数的补码 = {原码符号位不变} + {数值位按位取反后+1} or = {原码符号位不变} + {数值位从右边数第一个1及其右边的0保持不变,左边安位取反...
  • 参考《深入理解计算机系统》 本文从以下几个方面展开:数据类型与二进制整数表示方法浮点数表示方法无符号数与有符号数的转换常见错误:数据溢出,隐式转换反号,移位产生的问题 ...
  • 1.二进制数转换成十进制数:指数形式(2 的一次幂 二次幂等)相加 或者 先取四位数 四位数 转换成十六进制...5.正小数转换成二进制数:例如 0.25 一.0.25 * 2 = 0.5 取整数部分 0.5 * 2 = 1.0 取1 直到乘到小数部分为0
  • 整数如何在内存中表示 浮点数如何在内存中表示 原码、反码、补码介绍
  • 负数的原码:负数的绝对值的二进制的最高位变为1。 负数的反码:负数的原码的最高位不变,其余取反。 负数的补码:负数的反码+1。 例: 1.正数 9 (0000 1001 = 23+20=9) 原码:0000 1001 反码:0000 1001 ...
  • 浮点数的二进制存储

    2011-10-11 20:11:55
    -25的二进制存储方式 反码后+1 形成补码 3.5存储方式 浮点数的存储方式 12.5: 1. 整数部分12,二进制为1100; 小数部分0.5, 二进制是.1,先把他们连起来,从第一个1数起取24位(后面补0): 1100....
  • 文章目录十进制转二进制机器数与真值原码、反码、补码顺便说一说BCD码数的定点表示与浮点表示IEEE 754标准定点运算加法与减法运算溢出浮点运算加法与减法运算 十进制转二进制 正整数转二进制,这个简单,除2取余,倒...
  • 原码、反码、补码的第一位都是是符号位,0为正数,1为负数,不论小数整数都是如此。 eg:0.2(2)是个负数,1.2(2)是个正数,11112(2)是个负数,01112(2)是个正数。 十进制->二进制原码 二进制原码就是单纯...
  • 1.当两个二进制数运算时,整数位和小数位字长必须相等,即两个数的整数位数应相同,小数位数应相同;若两个数的位数不同或者运算时溢出,则应该扩展位数! 2.整数和小数 扩展位数的规则: (1)正数:有符号或无符号...
  • 这里都以整数为例,不考虑小数 ...反码:针对二进制的数值将0变成1,将1变成0 计算机两数相加比两数相减容易计算,所以想办法将减法转成加法,因此引入了补码,如下十进制: 假如计算机是无法计算十位:3-2=3+
  • 进制转换和运算

    2019-05-30 23:21:13
    进制转换二进制转换二进制转八进制互转二进制十进制互转二进制十六进制互转char类型转换小数二进制(了解)操作二进制原码反码补码 二进制转换 二进制 满2进1 借1当2 0-1 二进制转八进制互转 八进制 满8进1 借1当8 0...
  • 基础 1.小数默认是double类型,如果10.1要给float,float f =...3.二进制 0b|B开头,八进制0开头,十六进制0x|X开头 4.正数的原码补码反码一模一样 5.负数反码 对原码除符号位外,逐位取反 6.负数补码 对原码逐位取...
  • /* 十进制的减法 */ 111 - 126 = 111 + 999 - 126 + 1 - 1000 // 借位 = 111 + 873 + 1 - 1000 // -126 相对于 999(其进制系统的最高位) 的.../* 二进制的减法 */ 126 = 0x7e = 0111 1110 1111 1111 ...
  • 进制制数转换1-1 进制制数转换1-1-1 R进制转十进制:按权展开法1-1-2 十进制转R进制:短除法1-1-3 二进制、转八进制、转十六进制1-1-4 十进制小数二进制小数相互转化方法 考点:各进制制数相互间的转换,二进制的...
  • 进制的基础

    2020-02-05 21:39:32
    二进制反码表示法: 正数的原码与反码与补码是一样的,负数的原码只是符号位上的差异,补码是原码数据位取反再加一,反码是原码的数据位取反 定点数与浮点数 定点数的表示方法 分为纯正数,存小数,和存...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 178
精华内容 71
关键字:

二进制小数反码