c++长整数加法

最新推荐文章于 2024-07-12 10:45:15 发布

qq_40413184

最新推荐文章于 2024-07-12 10:45:15 发布

阅读量680

点赞数

文章标签： c++ 算法图论

本文链接：https://blog.csdn.net/qq_40413184/article/details/126484098

版权

这篇博客介绍了如何使用C++实现长整数加法，包括初始化映射表、计算实际长度、进行加法运算的详细步骤。通过示例代码展示了处理正负数和不同长度数字相加的过程。

摘要由CSDN通过智能技术生成

#include
#include
#include
#include
#include
#include
#include
#include"getopt.h"
using namespace std;

map<char,int> pair_map_capTnum;
map<int,char> pair_map_numTcap;
void init_map();
int length_act_cal(const char * num_ptr,const int length_1);
string cal_add(const char * num_ptr_add_1,const int length_1,const char * num_ptr_add_2,const int length_2,int n=10);
string minus_cal(const char * num_ptr_add_1,const int length_1,int index_act_1,int label_1,const char * num_ptr_add_2,const int length_2,int index_act_2,int label_2,int n);

#include “test2.h”

string cal_add(const char * num_ptr_add_1,const int length_1,const char * num_ptr_add_2,const int length_2,int n){
int label_1=1;
if( (*num_ptr_add_1) == ‘-’){
label_1=0;
}
int label_2=1;
if( (*num_ptr_add_2) == ‘-’ ){
label_2=0;
}
int index_act_1=0;
int index_act_2=0;
index_act_1=length_act_cal(num_ptr_add_1,length_1);
index_act_2=length_act_cal(num_ptr_add_2,length_2);
cout<<"The first number actual length is “<<length_1<<” “<<index_act_1<<” . And the laberl number is "<<label_1<<endl;
cout<<"The second number actual length is “<<length_2<<” “<<index_act_2<<” . And the laberl number is "<<label_2<<endl;

string result_add;
char step_bit_1;
char step_bit_2;
/*map<char,int>:: iterator it;
for(it=pair_map_capTnum.begin();it!=pair_map_capTnum.end();it++) {
    cout<<it->first<<"    "<<it->second<<endl;
}*/
//bool * ptr_lable= & over_label;
if(length_1==index_act_1 && length_2==index_act_2){//两个加数长度和有效位+1一致，表示没有有效数字，直接结果为0
    result_add="0";  
    cout<<result_add<<endl;
}
else if(length_1==index_act_1){
    int num_loop=0;
    while(num_loop>(length_2-index_act_2)){
        result_add.push_back(*(num_ptr_add_2+(length_2-num_loop)));
        ++num_loop;
    }
    cout<<result_add<<endl;
}
else if(length_2==index_act_2){
    int num_loop=0;
    while(num_loop>(length_1-index_act_1)){
        result_add.push_back(*(num_ptr_add_1+(length_1-num_loop)));
        ++num_loop;
    }
    cout<<result_add<<endl;
}
else if (label_1==label_2)
{   
    bool over_label=false; // 用于加法进位计算
    for(int i=0;i<(max((length_1-index_act_1),(length_2-index_act_2)));++i){
        int sum_bit=0;
            
        if(i>=min((length_1-index_act_1),(length_2-index_act_2))){ //计算位大于位数较短的加数时
            if((length_1-index_act_1)>(length_2-index_act_2)){ //加数1位数较大时
                step_bit_1=*(num_ptr_add_1+(length_1-i-1));
                
                if (over_label==true){
                    int step_num_1=pair_map_capTnum[step_bit_1];
                    sum_bit=step_num_1+1;
                    if (sum_bit>=n){
                        sum_bit-=n;
                        over_label=true;
                    }
                    else{
                        over_label=false;
                    }
                    
                    result_add.push_back(pair_map_numTcap [sum_bit]);
                    cout<< i<<" "<<result_add<<endl;
                }
                else{
                    
                    result_add.push_back(step_bit_1);
                    cout<< i<<" "<<result_add<<endl;
                }
            }
            else if((length_1-index_act_1)<(length_2-index_act_2)){//加数2位数较大时
                step_bit_2=*(num_ptr_add_2+(length_2-i-1));
                if (over_label==true){
                    int step_num_2=pair_map_capTnum[step_bit_2];
                    sum_bit=step_num_2+1;
                    if (sum_bit>=n){
                        sum_bit-=n;
                        over_label=true;
                    }
                    else{
                        over_label=false;
                    }
                    
                    result_add.push_back(pair_map_numTcap [sum_bit]);
                    cout<< i<<" "<<result_add<<endl;
                }
                else{
                    
                    result_add.push_back(step_bit_2);
                    cout<< i<<" "<<result_add<<endl;
                }
                
            }
        }
        else{
            step_bit_1=*(num_ptr_add_1+(length_1-i-1));
            step_bit_2=*(num_ptr_add_2+(length_2-i-1));
            int step_num_1=pair_map_capTnum[step_bit_1];
            int step_num_2=pair_map_capTnum[step_bit_2];
            
            if(over_label==true){
                sum_bit=step_num_1+step_num_2+1;
            }
            else{
                sum_bit=step_num_1+step_num_2;
            }    

            if(sum_bit>=n){
                sum_bit-=n;
                over_label=true;
            }
            else{
                over_label=false;
            }
            
            result_add.push_back(pair_map_numTcap [sum_bit]);
            cout<< i<<" "<<result_add<<endl;
        }
    }

    if (over_label==true){//按照位计算结束若有进1，则在最高位置为1.
        result_add.push_back('1');
        over_label=false;
    }
    if(label_1==0){ //若两个复数相加，则最终结果符号为-
        result_add.push_back('-');
    }
    reverse(result_add.begin(),result_add.end());
   
}
else if (label_1!=label_2){//两个符号不一致
    
    if((length_1-index_act_1)>(length_2-index_act_2)){
        result_add=minus_cal(num_ptr_add_1,length_1,index_act_1,label_1,num_ptr_add_2,length_2,index_act_2,label_2,n);
    }
    else if ((length_1-index_act_1)<(length_2-index_act_2)){
        result_add=minus_cal(num_ptr_add_2,length_2,index_act_2,label_2,num_ptr_add_1,length_1,index_act_1,label_1,n);
    }
    else if ((length_1-index_act_1)==(length_2-index_act_2)){
        for(int i=0;i<(length_1-index_act_1);++i){
            if (pair_map_capTnum[*(num_ptr_add_1+index_act_1+i)]==pair_map_capTnum[*(num_ptr_add_2+index_act_2+i)]){
                if(i==(length_1-index_act_1-1)){
                    result_add="0";
                }
                continue;    
            }
            else if(pair_map_capTnum[*(num_ptr_add_1+index_act_1+i)]>pair_map_capTnum[*(num_ptr_add_2+index_act_2+i)]){
                result_add=minus_cal(num_ptr_add_1,length_1,index_act_1,label_1,num_ptr_add_2,length_2,index_act_2,label_2,n);
                break;
                i=length_1-index_act_1;
            }
            else if (pair_map_capTnum[*(num_ptr_add_1+index_act_1+i)]<pair_map_capTnum[*(num_ptr_add_2+index_act_2+i)]){
                result_add=minus_cal(num_ptr_add_2,length_2,index_act_2,label_2,num_ptr_add_1,length_1,index_act_1,label_1,n);
                break;
                i=length_1-index_act_1;
            }
        }
    }
}
//cout<<"The result of process is "<<result_add<<endl;
return result_add;

}

int length_act_cal(const char * num_ptr,const int length_1){
string judge_str=“±0”;
int index_act=0;
for (int i=0;i<=length_1;++i){ //找到有效开始计数位，方便后续简易计算
string::size_type label_act;
char bit1=* (num_ptr+i);
//cout<< "judge bit is "<<bit1<<endl;
label_act=judge_str.find(bit1);
if (label_act==string::npos){
index_act=i;
i=length_1+1;
break;
}
}
return index_act;
}

void init_map(){
int num_A=65; //char A
int num_a=97;
int num_trans=10;
string num_array=“0123456789”;
for(int i=0;i<26;++i){
char cap_trans_A;
char cap_trans_a;
cap_trans_A=(char)(num_A+i);
cap_trans_a=(char)(num_a+i);
pair_map_capTnum.insert(pair<char,int>(cap_trans_A,(num_trans+i)));
pair_map_capTnum.insert(pair<char,int>(cap_trans_a,(num_trans+i)));
pair_map_numTcap.insert(pair<int,char>((num_trans+i),cap_trans_A));
if(i<=9){
pair_map_capTnum.insert(pair<char,int>(num_array[i],i));
pair_map_numTcap.insert(pair<int,char>(i,num_array[i]));
}
}
}

string minus_cal(const char * num_ptr_add_1,const int length_1,int index_act_1,int label_1,const char * num_ptr_add_2,const int length_2,int index_act_2,int label_2,int n){
string result_add;
char step_bit_1=‘0’;
char step_bit_2=‘0’;
bool under_label=false;// 用于减法借位计算
int minus_result_label=1;//默认减法结构为正数

for(int i=0;i<(max((length_1-index_act_1),(length_2-index_act_2)));++i){

        int minus_bit=0;                
        if(i>=min((length_1-index_act_1),(length_2-index_act_2))){ //计算位大于位数较短的加数时,此时已经比较过大小，数1比数2大，故直接计算结果
            
                step_bit_1=*(num_ptr_add_1+(length_1-i-1));
                minus_result_label=label_1;//最终计算结果符号与具有较大有效位数的数字的符号一致
                if (under_label==true){
                    int step_num_1=pair_map_capTnum[step_bit_1];
                    minus_bit=step_num_1-1;
                    if (minus_bit<0){
                        /*if (i<(max((length_1-index_act_1),(length_2-index_act_2))-1)){
                            minus_bit+=n;
                        }//对于还可以借位的情况，需要加上前面借来的位
                        else{
                            minus_bit=abs(minus_bit);
                        }*/
                        minus_bit+=n;
                        under_label=true;
                    }
                    else{
                        under_label=false;
                    }
                    
                    result_add.push_back(pair_map_numTcap [minus_bit]);
                    cout<< i<<" "<<result_add<<endl;
                }
                else{
                    result_add.push_back(step_bit_1);
                    cout<< i<<" "<<result_add<<endl;
                }
            /*else if((length_1-index_act_1)<(length_2-index_act_2)){//加数2位数较大时
                step_bit_2=*(num_ptr_add_2+(length_2-i-1));
                minus_result_label=label_2;//最终计算结果符号与具有较大有效位数的数字的符号一致
                if (under_label==true){
                    int step_num_2=pair_map_capTnum[step_bit_2];
                    minus_bit=step_num_2-1;
                    if (minus_bit<0){
                        minus_bit+=n;
                        under_label=true;
                    }
                    else{
                        under_label=false;
                    }
                    result_add.push_back(pair_map_numTcap [minus_bit]);
                    cout<< i<<" "<<result_add<<endl;
                }
                else{
                    result_add.push_back(step_bit_2);//没有借位运算直接保持当前位数据
                    cout<< i<<" "<<result_add<<endl;
                }                    
            }*/
        }
        else{
            step_bit_1=*(num_ptr_add_1+(length_1-i-1));
            step_bit_2=*(num_ptr_add_2+(length_2-i-1));
            cout<<"step_bit_1:"<<step_bit_1<<"  step_bit_2:"<<step_bit_2<<endl;
            int step_num_1=pair_map_capTnum[step_bit_1];
            int step_num_2=pair_map_capTnum[step_bit_2];
            cout<<"step_num_1:"<<step_num_1<<"  step_num_2:"<<step_num_2<<endl;
            
            if(under_label==true){
                minus_bit=step_num_1-step_num_2-1;
            }
            else{
                minus_bit=step_num_1-step_num_2;
            }
            if(minus_bit<0){
                if (i<(max((length_1-index_act_1),(length_2-index_act_2))-1)){
                    minus_bit+=n;
                }//对于还可以借位的情况，需要加上前面借来的位
                else{
                    minus_bit=abs(minus_bit);
                }
                under_label=true;//借位标志位置1，用于最终判断符号
            }
            else if(minus_bit>=0){
                under_label=false;
            }    
            result_add.push_back(pair_map_numTcap [minus_bit]);
            cout<< i<<" "<<result_add<<endl;
        }
}
    reverse(result_add.begin(),result_add.end());//需要旋转后计算减法结果的有效位
    int length_result=result_add.length();
    const char * ptr_result=& result_add[0];
    int bit_act_result=length_act_cal(ptr_result,length_result);//获取首位开始非零的第一个位置，即有效位
    if(bit_act_result==length_result){ //说明所有位上均为0
        result_add="0";
    }
    else{
        result_add.erase(0,bit_act_result);//清楚前面的非零位
    }
    if((length_1-index_act_1)==(length_2-index_act_2)){//两个数字有效位一致，需要结合借位及数1的符号进行判断
        if((under_label==true) && (label_1==1)){ //若数字1为正数，且有借位标志，则表示当前为负数
            minus_result_label=0;
        }
        else if((under_label==false) && (label_1==0)){//若数字1为负数，且没有借位，则表示结果哦为正数
            minus_result_label=0;
        }

    }
    if(minus_result_label==0){
        result_add.insert(0,"-");//未结果添加负号
    }
return result_add;

}
int main(int argc,char *argv[]){
init_map();
ifstream fin;
//读入设置参数
int opt=0;
int n=16;
string fin_name=“practise.txt”;
int o=10;
string param_name=“iof”;
/while((opt=getopt(argc,argv,param_nam