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

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位带符号二进制数为：

十进制数 -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。

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

希望为计算机初学者提供一些帮助。笔者学术不精，时间仓促，一些功能写的比较笨，但是勉强能用。不能体现补码的取值范围与反码不同的特点。
本代码在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");
        }
    }

}