希望为计算机初学者提供一些帮助。笔者学术不精，时间仓促，一些功能写的比较笨，但是勉强能用。不能体现补码的取值范围与反码不同的特点。
 本代码在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。
 
 
如果是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、反码 (1’s complement)
 
把所有的0变为1，所有的1变为0。
 如：
 10110010 Binary number
 01001101 1’s complement
 
2、补码 (2’s complement)
 
在反码的最低有效位上加1。
 补码 = 反码 + 1
 另一种求补码的方法：
 
从右边的最低有效位开始，往左边写下它们实际的位，直到遇到第一个1（包括1）
左边剩下的位求反码
 
如：
 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位带符号二进制数为：
 
 十进制数 -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 ------------------> [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.
 
 
注意：模数机器中是表示不出来的！！
 
 
对于正数，原码、反码。补码都相同。
 补码的优势：
 
符号位可以作为数值参与运算，而无须单独处理符号位；
减法运算可以转换成加法运算，这样可以简化运算。