精华内容
下载资源
问答
  • 不能体现补码的取值范围与反码不同的特点。 本代码在code::blocks17.12中正常运行 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 64 typedef struct rational_number{ char charnum[MAXSIZE...

    希望为计算机初学者提供一些帮助。笔者学术不精,时间仓促,一些功能写的比较笨,但是勉强能用。不能体现补码的取值范围与反码不同的特点。
    本代码在code::blocks17.12中正常运行

    #include <stdio.h>
    #include <stdlib.h>
    #define MAXSIZE 64
    typedef struct rational_number{
        char charnum[MAXSIZE];
        long long integer;//整数部分
        double decimal;//小数部分(浮点数)
        double approximate;//输入的数的近似浮点数
    }Rational;
    
    char* bin_plus_bin_direct(char* A, char* B);
    char* bin_to_truecode(long long num);
    
    //有理数扫描
    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;
    
        return num;
    }
    
    //(真)小数 10进制转16位原码
    char* dec_to_truecode(double num){
    
        char* res=malloc(18*sizeof(char));
        int i=2;
        memset(res,'0',17*sizeof(char));
        res[16]='\0';
        res[1]='.';
    
        if(num>=1){
            printf("需要真小数\n");
            return res;
        }
        if(num<0){
            res[0]='1';
            num*=-1;
        }else{
            res[0]='0';
        }
        while(i<16){
            if(num==0){
                break;
            }
            num*=2;
            if(num>=1){
                res[i++]='1';
                num-=1;
            }else{
                res[i++]='0';
            }
        }
        return res;
    }
    
    //(真)小数 10进制转16位反码
    char* dec_to_complementcode(double num){
        char* complementcode=dec_to_truecode(num);
        if(complementcode[0]=='0'){
            return complementcode;
        }
        for(int i=2;i<16;i++){
            if(complementcode[i]=='0'){
                complementcode[i]='1';
            }else if(complementcode[i]=='1'){
                complementcode[i]='0';
            }
        }
        return complementcode;
    }
    
    //(真)小数 10进制转16位补码
    char* dec_to_reversecode(double num){
        char* reversecode=dec_to_complementcode(num);
        if(reversecode[0]=='0'){
            return reversecode;
        }
        reversecode=bin_plus_bin_direct(reversecode,bin_to_truecode(1));
        return reversecode;
    }
    
    
    //整数 10进制转2进制
    long long int_to_bin(int num){
        long long flag=1;
        long long res=0;
        while(num!=0){
            res+=num%2*flag;
            flag*=10;
            num/=2;
        }
        return res;
    }
    
    //整数 2进制转16位原码
    char* bin_to_truecode(long long num){
        int weight;
        char* res=malloc(17*sizeof(char));
        if(countdigits(num,-1)>16){//
            printf("所给数大于16位,无法处理");
            res="0";
            return res;
        }
    
        if(num>0){
            res[0]='0';
            weight=1;
        }else{
            res[0]='1';
            weight=-1;
        }
        res[16]='\0';
        for(int i=15;i>0;i--){
            if(num==0){
                res[i]='0';
            }else{
                res[i]=weight*(num%10)+'0';
                num/=10;
            }
        }
        return res;
    }
    
    //整数 2进制转16位反码
    char* bin_to_complementcode(long long num){
        char* complementcode=bin_to_truecode(num);
        if(complementcode[0]=='0'){
            return complementcode;
        }
        for(int i=1;i<16;i++){
            if(complementcode[i]=='0'){
                complementcode[i]='1';
            }else if(complementcode[i]=='1'){
                complementcode[i]='0';
            }
        }
        return complementcode;
    }
    
    //整数 2进制转16位补码
    char* bin_to_reversecode(long long num){
        char* reversecode=bin_to_complementcode(num);
        if(reversecode[0]=='0'){
            return reversecode;
        }
        reversecode=bin_plus_bin_direct(reversecode,bin_to_truecode(1));
        return reversecode;
    }
    
    //整数 (直接的)二进制加法
    char* bin_plus_bin_direct(char* A, char* B){
        //1001011+1110
        char* res=malloc(17*sizeof(char));
        int flag=0;
        res[16]='\0';
        for(int i=15;i>=0;i--){
            if(A[i]=='0'){
                if(B[i]=='0'){
                    if(flag==0){//A=0,B=0,flag=0
                        res[i]='0';
                    }else if(flag==1){//A=0,B=0,flag=1
                        res[i]='1';
                        flag=0;
                    }
                }else if(B[i]=='1'){//A=0,B=1,flag=0
                    if(flag==0){
                        res[i]='1';
                    }else if(flag==1){//A=0,B=1,flag=1
                        res[i]='0';
                    }
                }
            }else if(A[i]=='1'){
                if(B[i]=='0'){
                    if(flag==0){//A=1,B=0,flag=0
                        res[i]='1';
                    }else if(flag==1){//A=1,B=0,flag=1
                        res[i]='0';
                    }
                }else if(B[i]=='1'){
                    if(flag==0){//A=1,B=1,flag=0
                        res[i]='0';
                        flag=1;
                    }else if(flag==1){//A=1,B=1,flag=1
                        res[i]='1';
                        flag=1;
                    }
                }
            }else if(A[i]=='.'){
                res[i]='.';
            }
        }
        return res;
    }
    
    //计算数字X中num出现的位数,当num=-1时取所有数
    int countdigits(long long X,int num){
        int res=0;
        if(num==-1){
            while(X!=0){
                res++;
                X/=10;
            }
        }else{
            while(X!=0){
                if(X%10==num)
                    res++;
                X/=10;
            }
        }
        return res;
    }
    
    int main()
    {
        Rational* num;
        while(1){
            num=scan_rational();
            if(num->decimal==0){
                //按整形处理
                printf("> 输入数:%d\n",num->integer);
                long long code_0=int_to_bin(num->integer);
                printf(" 原码:%s |",bin_to_truecode(code_0));
                printf(" 反码:%s |",bin_to_complementcode(code_0));
                printf(" 补码:%s \n",bin_to_reversecode(code_0));
                printf("> 输入数:%d\n",-1*num->integer);
                long long code_1=int_to_bin(-1*num->integer);
                printf(" 原码:%s |",bin_to_truecode(code_1));
                printf(" 反码:%s |",bin_to_complementcode(code_1));
                printf(" 补码:%s \n",bin_to_reversecode(code_1));
                printf("-------\n");
            }else if(num->integer==0){
                //按小数型处理
                printf("> 输入数:%f\n",num->decimal);
                printf(" 原码:%s |",dec_to_truecode(num->decimal));
                printf(" 反码:%s |",dec_to_complementcode(num->decimal));
                printf(" 补码:%s \n",dec_to_reversecode(num->decimal));
                printf("> 输入数:%f\n",-1*num->decimal);
                printf(" 原码:%s |",dec_to_truecode(-1*num->decimal));
                printf(" 反码:%s |",dec_to_complementcode(-1*num->decimal));
                printf(" 补码:%s \n",dec_to_reversecode(-1*num->decimal));
                printf("-------\n");
            }else{
                printf("暂时无法处理该类型\n");
            }
        }
    
    }
    
    
    展开全文
  • 补码  计算机是按照补码的形式存数字的。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取整。

    展开全文
  • 二进制数的反码和补码

    千次阅读 2019-01-16 22:12:54
    在大学的学习中,一开始自认为已经学会了反码与补码,但在看到多种表述之后,...首先从最一般的意义上,分别说一下二进制反码和补码: 1、反码 1’s complement 把所有的0变为1,所有的1变为0。 如: 10110010 B...

    在大学的学习中,一开始自认为已经学会了反码与补码,但在看到多种表述之后,反而是越来越乱,疑惑越来越多,即使记住了之后又会混淆,今天又看到了一次,为了防止以后再次忘记,写这篇博客记录一下(记录过程依据《数字电子技术(第十版)》,中英文结合)
    首先从最一般的意义上,分别说一下二进制的反码和补码:

    1、反码 (1’s complement)

    把所有的0变为1,所有的1变为0。
    如:
    10110010 Binary number
    01001101 1’s complement

    2、补码 (2’s complement)

    在反码的最低有效位上加1。
    补码 = 反码 + 1
    另一种求补码的方法:

    1. 从右边的最低有效位开始,往左边写下它们实际的位,直到遇到第一个1(包括1)
    2. 左边剩下的位求反码

    如:
    1011 1000 Binary number
    0100 1000 2’s complement

    这是在不区分正负数的情况下泛泛而谈的,其侧重点在于反码与补码如何操作,但实际上反码和补码的作用是用在带符号数上面的,下面进入重点。

    3、带符号数 Signed Number

    3.1 符号位 The Sign Bit

    带符号的二进制的最左边的那一位就是符号位,指出这个数为正数还是负数,0表示正数,1表示负数。
    下面介绍几种表示带符号数的形式。

    3.2 符号数值的形式 Sign-Magnitude Form

    最左边的一位是符号位,剩余的位都是数值位。其实也就是一般的带符号数的形式,数值位对于正数和负数来说都是二进制源码(in true (uncomplemented) binary)。如十进制数 +25 使用符号数值形式表示成8位带符号二进制数为:
    00011001
    十进制数 -25 表示为:
    在这里插入图片描述
    他们之间的唯一区别就是符号位不同。

    3.3 反码形式 1’s Complement Form

    正数的反码形式:与符号数值形式相同;
    负数的反码形式:相应正数的反码。也就是为相应正数的符号数值形式的每一位取反。

    应当注意的是并不是带符号数的反码都是每一位取反。
    反码和补码其实是为了解决正数和负数的加减法运算的,所以正数其实不用做什么改变,而负数改变形式后可以巧妙解决一些运算问题。比如减去某个数和加上这个数的补码是一样的,这就是为什么计算机在所有的算术运算中都使用补码来表示负整数。
    理解了反码是带符号数的一种表示形式及其目的,大概就能理解为什么正数的反码是其本身,下面要说到的补码也是一样的道理。

    举例:在反码表示形式中,
    十进制数 25 表示为:
    00011001
    十进制数 -25 表示为:
    11100110

    3.4 补码形式 2’s Complement Form

    正数的补码形式:与符号数值形式相同;
    负数的补码形式:负数的反码加1。

    举例:在补码表示形式中,
    十进制数 25 表示为:
    00011001
    十进制数 -25 表示为:
    11100111

    3.5 总结

    对于带符号数,
    正数的反码和补码与原码相同;
    负数的反码等于相应正数的反码,补码等于相应正数的补码。

    但这样的说法是会让人产生疑惑的,因为既然正数的反码等于原码,且负数的反码等于相应正数的反码(即等于正数的原码),那正数负数的表示不就一样了。我也觉得这种说法很有歧义,但如果把第二个反码看成是一种广义上的操作,即把每一位取反,这样就没问题了,总之只要能理解就好,有时候反码就是真的“反”码,实实在在的操作。但为了避免这种困惑,倒不如表述得更清楚直接些:

    对于带符号数,
    正数的反码和补码与原码相同;
    负数的反码等于相应正数的符号数值形式的各个位取反,补码等于反码加1。


    如有不合理的地方,欢迎指正。

    展开全文
  • 常用编码有原码、反码和补码。 原码 将符号位数字化0或1,数的绝对值与符号一起编码,即“符号-绝对值表示”。 X = +0101011 ------------------&amp;gt; [X]原 = 00101011 X = -0101011 -------------------&...

    一个数在计算机内的表达形式称为“机器数”,而它代表的数值称为机器数的“真值”。

    在这里插入图片描述
    常用编码有原码、反码和补码。

    原码

    将符号位数字化01,数的绝对值与符号一起编码,即“符号-绝对值表示”。
    X = +0101011 ------------------> [X] = 00101011
    X = -0101011 ------------------->[X] = 10101011

    对于带符号的纯小数,原码表示即将小数点左边一位用作小数位。
    X = 0.1011------------------>[X] = 0.1011
    X = -0.1011----------------->[X] = 1.1011
    原码表示无法处理零的二义性问题,且借位操作如果用计算机硬件来实现是很困难的。

    反码

    反码很少单独使用,常常作为求解补码的中间码。
    正数的反码与原码表示相同。
    负数的反码与原码的关系:
    负数反码的符号位与原码相同(仍用1表示),其余各位取反。
    在这里插入图片描述
    和原码一样,反码中的零也是不唯一的。
    当X为纯小数时:
    在这里插入图片描述

    补码

    模数的概念
    模数的物理意义,类似于计量器的容器。

    类比手表,当前时间为6点而手表为8点时调节有两个方法:

    • 反转2圈
    • 正转10圈
      8+(—2) = 8+10 (mod)12
      一个数加上一个负数等于这个数加上该负数的补数
    • 如果有n位整数(包括一位符号位),则模数为2n;
    • 如果有n位小数,小数点前一位为小数位,则模数为2.

    注意:模数机器中是表示不出来的!!
    在这里插入图片描述

    对于正数,原码、反码。补码都相同。
    补码的优势:

    1. 符号位可以作为数值参与运算,而无须单独处理符号位;
    2. 减法运算可以转换成加法运算,这样可以简化运算。
    展开全文
  • 无符号整型即我们数学中的正整数,在计算机中使用二进制的原码表示无符号整数,没有正负号占位。在32位电脑中,最大数为2^32-1,最小值为0。带符号整型带符号的整型,用最高位表示正负号。0表示正号,...
  • 原码、反码、补码 数值在计算机中是以补码的方式存储的,在探求为何... 一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的,在计算机用一个数的最高位存放符号, 正数为0, 负数为1。...
  • 注意,这个函数只能转换二进制小数,即形如 0.1101110001的格式,而形如110110.00101001则无法进行转换。 function d = bintodec(binstr) binstr = binstr(3:end); %提取小数点后的字符 len = length(binstr);...
  • 计算机中原码、反码、补码 正数的 原码 = 反码 = 补码 负数 反码 = 数的绝对值按位取反(最高位符号位除外)  补码 = 反码 +1 已知负数补码求原码 补码取反(最高位符号位不取反...二进制原码最大为0111111111111111=2
  • 2.对十进制转二进制完全char化,对二进制没有长度限制,只对十进制数有限制,只需要把int类型改成longlong类型就可以进一步扩大。 3.可以自定义输出的位长,为以后的调用做好准备。 #include <stdio.h> #...
  • 十进制(小数)转换为二进制(8位): 原码:首位是符号位,其余的n-1位表示数值的绝对值,数位不够用0补足。数值0的原码有两种形式:[+0] 原=00000000, [-0]原=10000000。 正数的原码、反码、补码都一致。 ...
  • 负数的原码:负数的绝对值的二进制的最高位变为1。 负数的反码:负数的原码的最高位不变,其余取反。 负数的补码:负数的反码+1。 例: 1.正数 9 (0000 1001 = 23+20=9) 原码:0000 1001 反码:0000 1001 ...
  • 对于初学者,迟早要面对进制的转换,或许
  • 二进制的四种码: 原码用于表示真值; 反码用于求反; 补码用于数据的表示与存储; 移码用于浮点数阶码表示。 码制 数值1 数值-1 1-1 【1+(-1)】 原码 ...
  • C语言中8进制和16进制怎么表示 ...所以C语言没有二进制输入,最多可用函数去实现。 八进制数的表达方法 C/C++规定,一个数如果要指明它采用八进制,必须在它前面加上一个0(数字0),如:123是十进制,
  • 二进制数据的表示方法2.1 有符号数与无符号数2.2 二进制的补码表示法2.3 二进制反码表示法2.4 小数二进制补码表示三.二进制的运算3.1 定点数与浮点数3.1.1 定点数的表示方法3.1.2 浮点数的表示方法3.1.3 定点数...
  • 什么叫二进制二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的...
  • 原码,反码,补码,都是计算机用二进制来表示数据的,计算机表示数据是由数据长度和符号位表示的,首位表示符号位,0表示正数,1表示负数,剩下的数据表示所要表示的数据。 什么是数据长度? 就是我们说的位数,...
  • 我们已经知道计算机中,所有数据最终都是使用二进制数表达。 我们也已经学会如何将一个10进制数如何转换为二进制数。 不过,我们仍然没有学习一个负数如何用二进制表达。   比如,假设有一 int 类型的数,值为5...
  • 是8位的二进制数据,前1位是符号位,后7位是数据真值(int类型的32位实在是太多了,就拿byte类型来举例子),首先说明一个概念,计算机是使用二进制的补码来存储汇编的机器码,这里边有三个知识点:原码、反码、补码...
  • 二进制(原码、反码、补码)(转载)

    千次阅读 2017-11-02 15:43:09
    bit(位):数据存储的最小单元...在计算机二进制系统中,位,简记为b,也称为比特(bit),每个二进制数字0或1就是一个位(bit),其中每 8bit = 1 byte(字节); Java 中的int数据类型占4个byte(字节),而1 byte(字节) =
  • 小数二进制计算t

    2014-09-15 10:06:28
    总结:整数取余数,小数取整数。 先看数的绝对值。...十进制小数-6.8125化为二进制,基数为2 (1)整数部分为5: 6/2=3……0 3/2=1……1 1/2=0……1 故整数6的二进制数为110 (2)小数部分为
  • 2.1 为了不累赘描述,本文以百度的二进制小数转换为十进制小数为例,如下图 2.2 十进制整数转二进制整数以及十进制小数转换为二进制小数如下 3. 原码、反码和补码 在理解二进制和十进制转换后,对于一个...
  • 二进制1.1.原码1.2.反码1.3.补码2.八进制3.十六进制4.位运算4.1.与(&)运算4.2.或(|)运算4.3.非(~)运算4.4.异或(^)运算4.5.移位(<<   >>   >>>)...
  • 1 机器数和真值1.1 机器数一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的,在计算机用一个数的最高位存放符号, 正数为0, 负数为1.比如,十进制中的数 +3 ,计算机字长为8位,转换成二进制...
  • 小数二进制转十进制 看到的都是 理论 没有代码, 今天把自己的公布下,欢迎指正(部分是借用别人的)如有疏漏,恳请指出。 #include <stdio.h> #include <string.h> #include <math.h> void ....
  • 在计算机中二进制定点表示方法有原码、反码、补码。 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;所谓原码就是二进制定点表示法,即最高位为符号位,“0”表示正,“1”表示负,其余位表示数值的大小...
  • 正数的原码0+二进制数值位 例如 3的二进制是011,他的原码是0011 负数的原码1+二进制符号位 例如 -3 ,他的原码是1011 补码 负数补码(用求补运算),从最低位往最高位顺序,遇到第一个1之前一直复制,之后的数...
  • 二进制: 只有0和1表示一个数值的大小 存在逢2进1的特点 二进制数的书写通常在数的右下方注上基数2,或在后面加B表示 如(0100 1000)B 或者 (0100 1000)2 八进制: 0-7 存在逢8进1的特点 八进制的书写通常是用...
  • 计算机基础:16、二进制--有符号数和无符号数1、有符号数和无符号数1.1、二进制原码表示法1.2、二进制的补码表示法1.3、二进制反码1.4、小数的补码1.5、原码、补码、反码总结 1、有符号数和无符号数 1.1、二进制...
  • 比如机器数10000101,单纯作为一个二进制数,我们转换为十进制是133。但是其真值是不计算符号位的,其最高位的1表示"-"。所以10000101的真值为-5。 下面的讨论以字长8为例 原码 原码=符号位+真值。比如: [+5]原码=0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,837
精华内容 2,734
关键字:

二进制小数反码