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


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

	
如果是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，用二进制表示的数位都不相同。此时由原码表示法变成补码表示法规则如下
	

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

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



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

一、十进制与二进制的相互转换
       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。
       原码的表示法很简单，虽然出现了+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。
       再试着用反码的方式解决一下原码的问题——
       0001+1110=1111，1+(-1)=-0；
       1110+1100=1010，(-1)+(-3)=-5。
       互为相反数相加等于0，虽然的到的结果是1111也就是-0。但是两个负数相加的出错了。
       反码的特点：
在反码表示中，用符号位表示数值的正负，形式与原码表示相同，即0为正；1为负。
在反码表示中，数值0有两种表示方法。
反码的表示范围与原码的表示范围相同。
反码表示在计算机中往往作为数码变换的中间环节。
五、补码
       补码：正数的补码等于它的原码；负数的补码等于反码+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。
       到这里，原码、反码的问题，补码基本解决了。
       在补码中也不存在-0了，因为1000表示-8。
       补码的特点：
       1. 在补码表示中，用符号位表示数值的正负，形式与原码的表示相同，即0为正，1为负。但补码的符号可以看做是数值的一部分参加运算。
       正数的补码表示就是其本身，负数的补码表示的实质是把负数映像到正值区域，因此加上一个负数或减去一个正数可以用加上另一个数（负数或减数对应的补码）来代替。
       从补码表示的符号看，补码中符号位的值代表了数的正确符号，0表示正数，1表示负数；而从映像值来看，符号位的值是映像值的一个数位，因此在补码运算中，符号位可以与数值位一起参加运算。
       2. 在补码表示中，数值0只有一种表示方法。
       3. 负数补码的表示范围比负数原码的表示范围略宽。纯小数的补码可以表示到-1，纯整数的补码可以表示到-2^n。
       由于补码表示中的符号位可以与数值位一起参加运算，并且可以将减法转换为加法进行运算，简化了运算过程，因此计算机中均采用补码进行加减运算。
八、为什么负数的补码的求法是反码+1
       因为负数的反码加上这个负数的绝对值正好等于1111，在加1，就是10000，也就是四位二进数的模，而负数的补码是它的绝对值的同余数，可以通过模减去负数的绝对值得到它的补码，所以负数的补码就是它的反码+1。
相关文档：计算机组成原理

对上篇文章进行了改进，主要在

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");
        }
    }

}

这里写目录标题
一.进制运算的基本知识
1.1 进制概述
1.2 进制运算的基础
二.二进制数据的表示方法
2.1 有符号数与无符号数
2.2 二进制的补码表示法
2.3 二进制的反码表示法
2.4 小数的二进制补码表示
三.二进制的运算
3.1 定点数与浮点数
3.1.1 定点数的表示方法
3.1.2 浮点数的表示方法
3.1.3 定点数与浮点数的对比
3.2 定点数的加减法运算
3.3 浮点数的加减法运算
3.4 浮点数的乘除法运算

一.进制运算的基本知识
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 浮点数的乘除法运算