整数和真小数二进制原码、反码、补码转换代码（改进）

对上篇文章进行了改进，主要在
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");
        }
    }

}