精华内容
下载资源
问答
  • C语言补码整数运算特性

    千次阅读 2017-11-06 17:04:00
    前言本篇博客以“SSD6-Exercise2-Data Lab: Manipulating Bits”为例,分析在对C语言中的整数采用补码(two’s-complement)编码的机器上,其整数运算的特性。

    前言

    本篇博客以“SSD6-Exercise2-Data Lab: Manipulating Bits”为例,分析在对C语言中的整数采用补码(two’s-complement)编码的机器上,其整数运算的特性。


    补码

    定义

    最常见的有符号数的计算机表示方式就是补码(two’s-complement)形式。在这个定义中,将字的最高有效位解释为负权(negative weight),我们用函数B2T(Binary to Two’s-complement的缩写,长度为 w)来表示。

    如:

    B2T ([0001]) = -0 + 0 + 0 + 1 = 1
    B2T ([0101]) = -0 + 4 + 0 + 1 = 5
    B2T ([1011]) = -8 + 0 + 2 + 1 = -5
    B2T ([1111]) = -8 + 4 + 2 + 1 = -1

    定理1

    B2T ([11···1]) = -1

    证明:假设B2T ([11···1]) 共有w位,则其值为 -2^(w-1) + 2^(w-2) + ··· + 2^0. 根据等比数列求和公式,易证该值为-1.

    定理2

    对于w位的补码B2T来说,其边界值Tmax与Tmin分别为:

    Tmax = B2T ([01···1]) = 2^(w-1) - 1

    Tmin = B2T ([10···0]) = -2^(w-1)

    即有:~Tmax = Tmin


    整数运算

    我们先以表格的形式,宏观介绍C语言中的位级运算、逻辑运算和移位运算。

    运算种类 运算符 主要说明
    位级运算 |, &, ~, ^ 对应于布尔运算中的OR, AND, NOT, EXCLUSIVE-OR
    逻辑运算 ||, &&, ! 对应于命题逻辑中的OR, AND, NOT
    移位运算 <<, >> 分为左移与右移,右移运算包括逻辑右移与算数右移

    !~有什么区别?

    注意:逻辑运算很容易和位级运算相混淆,但是它们的功能是完全不同的。

    • 逻辑运算中认为所有非零的参数都表示TRUE,而参数0表示FALSE.

    • 逻辑运算的结果为一个布尔值,而位级运算的结果依然为一个.

    • 逻辑运算的运算符常称为,而位级运算的运算符常称为取反异或.

    因此,!是逻辑运算中的运算符,而~是位级运算中的取反运算符。

    逻辑右移与算术右移

    我们先来看左移运算<<.

    对操作数x执行x<<k运算,即x向左移动k位。此运算会丢弃最高的k位,并在右端补k0.

    相应而言的右移运算>>.

    对操作数x执行x>>k运算,即x向右移动k位。此运算会丢弃最低的k位,那么在左端需要补充的k个位是什么呢?

    若执行逻辑右移,则补充k0,这类似于左移运算.

    若执行算术右移,则补充k最高有效位的值。

    且几乎所有的编译器/机器组合都对有符号数使用算术右移,对无符号数采用逻辑右移。


    运算特性

    我们通过完成这下面这10个函数,来体会补码的整数运算特性。

    /* 
     * bitAnd - x&y using only ~ and | 
     *   Example: bitAnd(6, 5) = 4
     *   Legal ops: ~ |
     *   Max ops: 8
     *   Rating: 1
     */
    int bitAnd(int x, int y) {
        return ;
    }
    
    /* 
     * bitOr - x|y using only ~ and & 
     *   Example: bitOr(6, 5) = 7
     *   Legal ops: ~ &
     *   Max ops: 8
     *   Rating: 1
     */
    int bitOr(int x, int y) {
        return ;
    }
    
    /*
     * isZero - returns 1 if x == 0, and 0 otherwise 
     *   Examples: isZero(5) = 0, isZero(0) = 1
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 2
     *   Rating: 1
     */
    int isZero(int x) {
        return ;
    }
    
    /* 
     * minusOne - return a value of -1 
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 2
     *   Rating: 1
     */
    int minusOne(void) {
        return ;
    }
    
    /* 
     * TMax - return maximum two's complement integer 
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 4
     *   Rating: 1
     */
    int tmax(void) {
        return ;
    }
    
    /* 
     * bitXor - x^y using only ~ and & 
     *   Example: bitXor(4, 5) = 1
     *   Legal ops: ~ &
     *   Max ops: 14
     *   Rating: 2
     */
    int bitXor(int x, int y) {
        return ;
    }
    
    /* 
     * getByte - Extract byte n from word x
     *   Bytes numbered from 0 (LSB) to 3 (MSB)
     *   Examples: getByte(0x12345678,1) = 0x56
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 6
     *   Rating: 2
     */
    int getByte(int x, int n) {
        return ;
    }
    
    /* 
     * isEqual - return 1 if x == y, and 0 otherwise 
     *   Examples: isEqual(5,5) = 1, isEqual(4,5) = 0
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 5
     *   Rating: 2
     */
    int isEqual(int x, int y) {
        return );
    }
    
    /* 
     * negate - return -x 
     *   Example: negate(1) = -1.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 5
     *   Rating: 2
     */
    int negate(int x) {
        return ;
    }
    
    /* 
     * isPositive - return 1 if x > 0, return 0 otherwise 
     *   Example: isPositive(-1) = 0.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 8
     *   Rating: 3
     */
    int isPositive(int x) {
        return ;
    }

    下面则分模块讨论:每个函数所代表的补码的整数运算特性。

    逻辑运算与位级运算

    这两个函数要分别实现位级运算中的操作。

    由于二进制表示的数位只有0与1,所以我们在思考位级运算的时候,可以借助逻辑运算/命题逻辑中的一些重要定律,即:把位级运算中的0想象成逻辑运算中的FALSE,把1想象成TRUE.

    在命题逻辑中,有重要的德摩根律

    对命题p、q,有:

    (1)p q (p q)
    (2)p q (p q)

    相应地,可以很快地推导出位级运算中的操作。

    /* 
     * bitAnd - x&y using only ~ and | 
     *   Example: bitAnd(6, 5) = 4
     *   Legal ops: ~ |
     *   Max ops: 8
     *   Rating: 1
     */
    int bitAnd(int x, int y) {
        return ~(~x | ~y);
    }
    
    /* 
     * bitOr - x|y using only ~ and & 
     *   Example: bitOr(6, 5) = 7
     *   Legal ops: ~ &
     *   Max ops: 8
     *   Rating: 1
     */
    int bitOr(int x, int y) {
        return ~(~x & ~y);
    }

    那么对于异或操作,命题逻辑中又是怎么定义的呢?

    对命题p、q,有:
    p q (p q) (p q)

    故相应的:

    /* 
     * bitXor - x^y using only ~ and & 
     *   Example: bitXor(4, 5) = 1
     *   Legal ops: ~ &
     *   Max ops: 14
     *   Rating: 2
     */
    int bitXor(int x, int y) {
        return (x & ~y) | (~x & y);
    }

    异或的用途

    从上面关于异或的定义中我们也可以看到:

    p q (p q) (p q)

    即:只有当pq取值不同时,p ⊕ q 才为1(TRUE).

    那么同样地,在位级运算中,我们可以通过异或的这一性质,用来判断两个数值是否相等

    /*
     * isZero - returns 1 if x == 0, and 0 otherwise 
     *   Examples: isZero(5) = 0, isZero(0) = 1
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 2
     *   Rating: 1
     */
    int isZero(int x) {
        return !(x^0);
    }
    
    /* 
     * isEqual - return 1 if x == y, and 0 otherwise 
     *   Examples: isEqual(5,5) = 1, isEqual(4,5) = 0
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 5
     *   Rating: 2
     */
    int isEqual(int x, int y) {
        return !(x^y);
    }

    需要注意的是:这里的!不能改为,因为这个函数所做的是一个逻辑运算:判断某个数是不是 0(或x与y是不是相等).(从函数的名字isZeroisEqual就可以看的出来:最外层进行的必须是一个逻辑运算)

    特别的数:-1

    在最上方的时候我们已经提过了补码中的一个重要定理:

    B2T ([11···1]) = -1

    那么如何取到[11···1]呢,很简单,因为数0可以表示为[00···0],所以对0进行按位取反操作即可。

    /* 
     * minusOne - return a value of -1 
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 2
     *   Rating: 1
     */
    int minusOne(void) {
        return ~0;
    }

    特别的数:0

    我们来看isPositive函数:判断一个数是否为正,对正数,返回值为1;对非正数,返回值为0.

    根据补码的定义,我们很容易知道:最高有效位为1的数是负数。

    那么最高有效位是0的数是正数吗?

    不然,因为对于0来说,它的每一位都是0.

    “数x最高有效位是否为1”很好判断:让x的最高有效位先跑到最右边,也就是x>>31,然后在与1按位取或,若最终结果为1,说明最高有效位就是1.

    所以isPositive函数需要满足两个命题:

    (1)x的最高有效位是0,即((x>>31) & 1) == 0
    (2)x不是0,即x != 0

    即:函数的返回值为:(((x>>31) & 1) == 0) && x(记为式*),由于具有运算符号的限制,我们还要对它继续进行转化。

    对于((x>>31) & 1) == 0来说,由于(x>>31) & 1的结果只有1位,所以这个逻辑运算可以表达成:!((x>>31) & 1).

    那么式*就变为了:!((x>>31) & 1) && x,由于命题!((x>>31) & 1)的值是0或1,命题x的值也是0或1,所以逻辑运算符&&退化为:两个只有一个数位的数值的按位取与运算

    /* 
     * isPositive - return 1 if x > 0, return 0 otherwise 
     *   Example: isPositive(-1) = 0.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 8
     *   Rating: 3
     */
    int isPositive(int x) {
        return (!((x>>31) & 1)) & x;
    }

    边界值:TmaxTmin

    由补码的定义我们可以知道:

    对于w位的补码B2T来说,其边界值Tmax与Tmin分别为:

    Tmax = B2T ([01···1]) = 2^(w-1) - 1

    Tmin = B2T ([10···0]) = -2^(w-1)

    即有:~Tmax = Tmin

    那么我们需要得到Tmin,即[10···0]呢?

    只需要[10···0] = 1<<31即可,再对其按位取反,便得到了Tmax.

    /* 
     * TMax - return maximum two's complement integer 
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 4
     *   Rating: 1
     */
    int tmax(void) {
        return ~(1<<31);
    }

    移位运算的潜在含义

    下面我们来看getByte函数:

    /* 
     * getByte - Extract byte n from word x
     *   Bytes numbered from 0 (LSB) to 3 (MSB)
     *   Examples: getByte(0x12345678,1) = 0x56
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 6
     *   Rating: 2
     */
    int getByte(int x, int n) {
        return ;
    }

    其中,LSB(Least Significant Bit)是“最低有效位”,MSB(Most Significant Bit)是“最高有效位”。

    举个例子:对于十六进制数0x12345678,其二进制表示为[0001 0010 ··· 1000],其最低有效位是排列在最右那个0,而最高有效位是排列在最左边的那个0.

    因此,这个函数想要表达的意思就是说:n的值从0到3,且0代表最低有效位(可以理解为排在最右边的那个字节,也就是0x78),3代表最高有效位(可以理解为排在最左边的那个字节,也就是0x12),同理:1代表的就是0x56.

    那么我们该如何实现这个函数的功能呢?

    我们可以把这个问题分三个步骤考虑:

    1. 通过n的值,我们就得到了其所代表的两个数位(比如:当n为1时,我们就得到,这两个数位是5 6;当n为2时,这两个数位就是3 4

    2. 我们又知道,最终得到的这两个数位,其实是在“最右边”的。依然拿n为1来举例子,我们在第一步得到了5 6,但我们得把这两个数放在最右边啊,否则不就成了0x5600吗,它一点都不等于0x56,即0x0056.

    3. 第三步,我们把这两个数位放到最右边以后,还得保证它的左侧全部是0。这要怎么做呢——只需要让它和0x000000ff进行按位与操作即可。

    这样转化了问题之后,我们的难点只剩下一个了,也就是上述过程中的第二步:我们要把这两个数位向右移动几位呢?

    由于 1 byte = 8 bits,所以这个问题也很简单了:当n=1时,向右8位;当n=2时,向右16位…也就是说,我们只需要向右移动8n位就好了。

    那么这个函数就很好写了:

    /* 
     * getByte - Extract byte n from word x
     *   Bytes numbered from 0 (LSB) to 3 (MSB)
     *   Examples: getByte(0x12345678,1) = 0x56
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 6
     *   Rating: 2
     */
    int getByte(int x, int n) {
        int offset = 8 * n;
        int a = x >> offset;
        int b = 0x000000ff;
        return a & b;
    }

    细心的读者可能发现了,我们这个函数的实现是不符合题目要求的。题目中还有一个额外的要求,即:我们能够使用的运算符,只有! ~ & ^ | + << >>,这其中没有乘号*.

    那么,8 * n又该怎么表示呢?

    这个问题也很简单。我们都喜欢拿十进制来思考问题,就比如说:100 * x是多少呢?小学生都知道:在x的右边添上两个0啊!那1000 * x呢?添3个0啊!

    好了,那么回到我们的二进制。2 * x是多少呢?大学生应该可以知道了:在x的右边添1个0啊!那8 * x呢?添3个0啊!

    这也就是移位运算的潜在含义了,我们把x向左移k位,其实就是在说:把x * 2^k.

    经过修正后的函数如下:

    /* 
     * getByte - Extract byte n from word x
     *   Bytes numbered from 0 (LSB) to 3 (MSB)
     *   Examples: getByte(0x12345678,1) = 0x56
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 6
     *   Rating: 2
     */
    int getByte(int x, int n) {
        int offset = n << 3;
        int a = x >> offset;
        int b = 0x000000ff;
        return a & b;
    }

    补码中的“相反数”

    /* 
     * negate - return -x 
     *   Example: negate(1) = -1.
     *   Legal ops: ! ~ & ^ | + << >>
     *   Max ops: 5
     *   Rating: 2
     */
    int negate(int x) {
        return ~x+1;
    }

    在补码中有这样一个定理:

    对于数x来说,-x = ~x + 1.

    我们考虑用数学归纳法来证明这个式子:

    (1)考虑只有2位的补码。此时,只有[00] = 0[01] = 1[10] = -2[11] = -1这四个数,容易发现-x = ~x + 1.

    (2)现假设此结论对于拥有k位的补码成立.

    (3) 下面证明此结论对于拥有k + 1位的补码成立。

    由于篇幅与表达所限,只提供证明思路如下:

    • 需要利用假设(2)的条件。

    • 需分别讨论:对于k + 1位的补码,当其最高有效位(即符号位)分别为0、1时的情况。


    参考资料

    [1]《深入理解计算机系统》(第3版). Randal E. Bryant, David R.O’Hallaron 著.

    [2] 博客:SSD06 Exercise02 个人解答.

    展开全文
  • c语言补码

    2020-03-21 18:01:07
    面试问算法,转补码怎么写? 整数还比较简单,负数有点卡壳,今天搜一下,发现一个很巧妙的写法(主要是比较短,2333) 转自:https://blog.csdn.net/wyt734933289/article/details/72889835 #include <...

    面试问算法,转补码怎么写? 整数还比较简单,负数有点卡壳,今天搜一下,发现一个很巧妙的写法(主要是比较短,2333)

    转自:https://blog.csdn.net/wyt734933289/article/details/72889835

     

    #include <cstdio>
    
    int main()
    {
        int num[20], cnt = 0;
        short a = -4321; //0001 0000 1110 0001   1110 1111 0001 1110
        //short a = 4321;
        unsigned short b = a; // 0011 0000 1110 0001   1100 1111 0001 1110
        printf("%hx\n", b); //61215   1110 1111 0001 1111
        while(b)
        {
            num[cnt++] = b & 1;
            b >>= 1;
        }
        for(int i = cnt - 1; i >= 0; i--)
            printf("%d ", num[i]);//结果可与2018王道计组复习P45页对比
        return 0;
    }

    关于为什么要加上unsigned,原文章讲的还比较清楚,个人的一些理解,在计算机中数字以补码形式保存,然后unsigned是用来避免算数右移时,读取符号位出现错误。

    展开全文
  • C语言补码和char数据类型的理解

    千次阅读 2017-02-04 11:01:46
    如果一个整数型在内存中只占用n个比特,则第n+1位为1,其余为0(十进制中等于2n),则让这个数(2n)减去想要存储的负数的绝对值,就是这个负数的二进制表示(是它的补码)。 这个负数和它对应的正数之和相加,则...

    补码

    补码主要用于解决负数的储存和运算。
    以下是一些不正规的理解。

    如果一个整数型在内存中只占用n个比特,则第n+1位为1,其余为0(十进制中等于2n),则让这个数(2n)减去想要存储的负数的绝对值,就是这个负数的二进制表示(是它的补码)。
    这个负数和它对应的正数之和相加,则变为那个数(2n),但由于该整数型总共只有n个比特,故n+1位会被直接丢掉到,导致相加为0。
    这是一种考虑如何存储负数的思路——负数与它对应的正数相加之和为零嘛。

    这也就导致一个问题,比如char整数类型,11111111作为补码到底理解为-1还是255?
    由思路我们可以知道,我们有char整数类型,共8个比特的占用,如果只表示正数,则最大只能表达11111111,即0到255之间的数,共有256个数。我们现在还希望它来存储负数,并且思路是
    1+(-1)=0 2+(-2)=0 … 也就是说我们其实是把256个数掰开来用,1,-1;2,-2…这样一对一对
    因此总共有128对,最大是-128和128,最小是0和-0;
    0和-0是一回事儿但是128和-128不是一回事情,128与-128都是10000000,不过规定100000000是-128。


    char数据类型

    • ASCII码中利用八个bite,从0d(0000 0000b)到127d(0111 1111b),每个二进制数均对应一个特定的字符。char数据类型能有效接收这128个字符。但不论传给什么数据类型,字符也好数值也罢,其最终都以二进制数保存。比如定义变量c是char数据类型,不论赋给c的是数值49还是字符’1’,它们在内存中均是以00110001来存储的。

    • 当输出要求中要求%c,则编译器理解为要把存储的二进制码转换为对应的字符输出。而如果输出要求为%d,编译器理解为把二进制数转换为十进制数输出。

      • 由于char数据类型只接受一个字节的长度。因而如果传入的数据大于255d(1111 1111b),则超出第八位的溢出部分会直接丢失。比如821d(0011 0011 0101‬b),存储时只会保留后八个比特,因而实际上存储为( 0011 0101‬b),对应十进制为53d,最终会输出53。
      • 由于补码的规则,当传入的数或者经过溢出丢失处理后的数不存在溢出问题(小于255d),但大于127d对应二进制(1000 0000b),会被当做补码处理,最终输出会是负数。
    • C中scanf(“%c”,&c)的意思是取一个字符并将它赋值给c。如果这里输入1,则会因为%c而被强行转换为字符’1’,然后用其对应的二进制码(0011 0001b)存储,当要求以%d输出时,结果会是 49。

    展开全文
  • C语言整数赋值流程

    2021-03-03 20:21:24
    C语言整数赋值流程(溢出原理) 首先,正数的补码与原码相同。 计算机内数值的储存和计算方式是补码。 当我们打出a=255时,如果a是个整数变量,则有四个字节,即32位,所以255原码和补码是00000000 00000000 ...

    C语言整数赋值流程(溢出原理)

    首先,正数的补码与原码相同。 计算机内数值的储存和计算方式是补码

    当我们打出a=255时,如果a是个整数变量,则有四个字节,即32位,所以255原码和补码是00000000 00000000 00000000 11111111 (不同于a为字符变量)。赋值给a后,a的原码和补码同为00000000 00000000 00000000 11111111 。当计算机读取a时,a仍是255。

    但是当a为字符变量时,a只有一个字节,即8位。此时255的原码和补码为(0)11111111。强行赋值后a的原码和补码为11111111 (溢出了一个0),此时计算机读取出来的数字为-127。这是因为最高位不再是255括号中的0,是a中的1。

    a=-255时,同理,a为整数时,-255的原码为10000000 00000000 00000000 11111111,补码为11111111 11111111 11111111 00000001。赋值给整数a后,a的补码为11111111 11111111 11111111 00000001。计算机读取时,读出仍为-255。
    但是当a为字符变量时,-255的原码为10000000 11111111,补码为11111111 00000001。赋值给a后,a为00000001,计算机读取出来为1。

    总结:

    1. 需储存的十进制数字绝对值先转化成纯二进制数值(先忽略符号)。例如255为11111111,-255也为11111111。
    2. 算入符号,变成原码(机器码)。根据变量类型,整数最高位为0,负数最高位为1。例如整数型的255为00000000 00000000 00000000 11111111,字符型的255为(0)11111111。整数型的-255为10000000 00000000 00000000 11111111,字符型的-255为(1)11111111。
    3. 根据规则,将原码转成补码。
    4. 将补码从后往前,每位依次对应给变量的每位,溢出的直接舍弃。
    5. 当计算机读取时,将变量的最高位看作符号位,其余的是数值位,这才有了255赋给字符a,导致输出为-127 。
    6. 计算机读取补码时,数值位最后一位减一,再反转,即原码转补码的反操作。最终得到原码,再转化成十进制数字。在这里插入图片描述
    展开全文
  • c语言补码

    2019-09-20 16:57:20
    整数的反码补码都与原码一样,负数的反码,是原码保持符号位不变,其他取反,反码加一为补码,溢出的数据,直接去掉最左边。 11000 0000(源码) — 10111 1111(取反) — 11000 0000(加一) — 80(1000 0000)(去左端...
  • 首先先介绍一下整数在计算机中表示方法,数在计算机中都是用二进制表示,但是字节长度就不一定了,不同的机器可能就不一样而且在计算机系统中,补码是最重要的编码,数值一律用补码来表示和存储移码(又叫增码)是符号...
  • C语言 补码

    千次阅读 2019-02-23 16:26:27
    1.正整数补码是其二进制表示,与原码相同 2.负数求补,将其对应正数二进制表示所有位取反(包括符号位, 0 变 1, 1变 0)后加 1。 一个8位的空间,如果表示无符号数范围是 [0,255] 即 unsigned char [0,2...
  • 数据是以二进制补码的形式储存到计算机中的,正数的原码,反码,补码相同,负数补码是反码加一,0代表正数,1代表负数,最高位是符号位,例如10的原码是0000 1010 ,10的反码,补码相同,-10的原码是1000 1010,反码...
  • 计算机中的符号数有三种表示方法,即原码、反码和补码。三种表示方法均有符号位和数值位两部分,符号位都是用0表示“正”,用1...负整数补码 是 它的反码(反码:就是它绝对值的原码按位取反)+1; 比如以整数 ...
  • 一、整数在内存中的存储。 整型类型有: short (短整型 )、int(整型)、long(长整型)、char(字符)。 如果我们创建一个变量要在内存中开辟一段空间。空间的大小由变量的类型决定。 计算机中有符号数有三种:...
  • c语言学习——补码

    2019-04-16 10:52:02
    补码 十进制转二进制 正整数转二进制 除2取余,直至商为0,余数倒序排列。 负整数转二进制 先求与该负数相对应的正整数的二进制代码,然后将所有位取反,末尾加1,不够位 数是,左边补1(看类型 int为4个字节时...
  • 目录一、实验环境二、C语言整数简介1、类型说明符(1) signed和unsigned(2) 省略书写2、sizeof运算符-计算当前环境下各类型的字节数三、整数存储-原码,反码,补码1、原码2、反码3、补码四、总结五、文末声明 ...
  • 最常见的有符号数的计算机表示方式就是补码,最高位为符号位。 原码表示 在看补码之前先复习一下原码 decimal binary decimal binary 0 0000 -0 1000 1 0001 -1 1001 2 0010 -2 1010 3 0011 -3 1011 ...
  • 原码 也叫 符号-绝对值码 最高位0表示正,1表示负,其余二进制位是该数字的绝对值的二进制位.如-5的原码为10101 原码简单易懂,但加减运算复杂,存在加减乘除四种...补码 十进制转二进制 正整数转二进制 除2取余,直至商为
  • 注意: 数据在计算机中存的二进制 ,其实就是补码! 假设:输入一个数num, num & 0x01; //让num和1相与 这时候和1相与的 就是num的补码。 所以,想要显示一个数的补码,只要对数进行位运算操作,把它的二进制...
  • 所有整数在计算机中都是以补码来存储的,首位0,表示正数,首位1,表示负数 什么是补码? 1、正整数补码是基本身的二进制数 2、负整数补码是: 先求该负整数相对应的正整数的二进制代码,然后全部取反,末尾...
  • 3、举例证明整数在计算机内是以补码的形式存在(以负数为例) 4、整数的位操作:按位且&、或|、异或^、取反~ 5、整数的位移操作:左位移,右位移 6、整数的按位与&、位移、异或^的应用举例 一、进制...
  • 原码、反码、补码、移码的作用?  在计算机内,机器数有无符号和带符号数之分。无符号数表示正数,在机器数中没有符号位。位于无符号数,若约定小数点的位置在机器数的最低位之后,则是纯整数;若约定小数点的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 422
精华内容 168
关键字:

c语言整数补码

c语言 订阅