cpp设计并实现大整数

---

前言

第三次发csdn，心情还是有些许的激动

---

一、设计大整数类

功能：简易设计类似python的大整数加法。

1.第一步：大整数类的输入和部分功能的构建

class HugeInteger
{
private:
    string integer;               //用string类型储存数值
public:

    HugeInteger();               //构造函数

    HugeInteger(int a);          //赋值
    HugeInteger(string a);

    HugeInteger operator+(HugeInteger a);  //重载"+"运算符，实现不同类型相加
    HugeInteger operator+(int);
    HugeInteger operator+(string);

    friend ostream& operator<<(ostream& os,HugeInteger);//重载输出运算符,实现连续输出
};

在实现相加或者后续拓展运算时，若使用程序内置的整数类型可能出现溢出错误等情况，而且不同类型的运算可能无法进行，从而我们就有需求将大整数类（后期可以扩展至整数域）作为标准，正整数计算均已大整数类进行。
*本文章主要实现大正整数的加法

2.第二步：用string类保存大整数数值

string integer;               //用string类型储存数值

string类的功能很完善，能够动态的分配空间，使得我们不用担心数值溢出等问题，提高效率；并且用string类可以通过字符串的拼接，解决加法进位问题（若宽展至负整数，不仅利于计算，而且输出可以通过拼接，非常简便）

3.第三步：关于大整数类的赋值

    HugeInteger(){                //默认为00，其中第一个0为占位符，从第二位开始为数值，输出时可以省略
        integer="00";
    };

    HugeInteger(int a){           //将int类型转化为HugeInteger类型
        string x;
        x=to_string(a);           //类型转换函数包含在头文件<string>
        integer="0"+x;
    } ;
    HugeInteger(string a){        //将string类型转化为HugeInteger类型
        integer="0"+a;
    };

因为数字相加会存在进位，在数字前面拼接 “0” 可以避免在后续运算中 首位相加 进一 后 超出字符串长度，从而系统报错。
*即实际储存值为“0XXX~~XX”
*并且实现了不同类型数值读取并赋值

4.第四步：大整数加法的实现及兼容性

    HugeInteger operator+(HugeInteger a){       //加法运算符（+）重载，实现HugeInteger类型相加
        HugeInteger INT,max0;
        max0=a;
        INT=*this;

        int Size,Size1,Size2,n=0;

        Size1=INT.integer.size();
        Size2=a.integer.size();

        if (INT.integer.size()>a.integer.size())
        {
            n=1;
            max0=INT;
        };
        if (n==0) Size=Size1;
        else Size=Size2;
        for (int i=0;i<Size;i++)
        {
            int x=0,y=0,z=0;
            x=INT.integer[Size1-i]-'0';     //将那一位对应的字符转换成字符所代表的数字
            y=a.integer[Size2-i]-'0';
            z=x+y;
            x=z%10;
            y=z/10;
            INT.integer[Size1-i]=x+'0';    //将数字转化成字符，再替代此位置字符
            int j=i;
            while(y==1){               //实现加1后连续进位
                if (INT.integer[Size1-j-1]=='9') INT.integer[Size1-j-1] ='0';
                else{
                    INT.integer[Size1-j-1]+=y;
                    y=0;
                }
                j++;
            }
        };

        return INT;
    };
    HugeInteger operator+(int a){     //加法运算符（+）重载，实现HugeInteger类型与int类型相加

        HugeInteger INT(a);           //将int类型转化成HugeInteger类型，再做加法
        INT=*this+INT;
        return INT;
    };
    HugeInteger operator+(string a){  //与上同理
        HugeInteger INT(a);
        INT=*this+INT;
        return INT;
    };

实现相加的原理非常简单，虽然我写得非常凌乱，但主要思想就是小学老师教的加法——列竖式，将两个数右对齐，从个位开始对位相加，得到的数除以10取余，结果即为和的那一位所对应的数字，若整除10的值为1，则需要向左边一位加1。

若数字长度不同，则仅需将较短数字加上即可（循环时以短数字的长度控制循环次数）

实现大整数类的相加后，不同类型的相加可以通过函数复合使用实现

5.第五步：输出大整数类

    friend ostream& operator<<(ostream& os,HugeInteger a){      //重载<<符，实现连续输出
        if (a.integer[0]=='0')    //判断首位是否是0，若为0，则从第二位开始输出                        
        {
            int k;
            k=a.integer.size();
            for (int i=1;i<k;i++)
            {
                os<<a.integer[i];
            }
            return os;
        }
        else
        {
            os<<a.integer;
            return os;
        }
   };

重载输出运算符"<<"实现连续输出
*若第一位为 “0” 则从第二位开始输出
*函数返回类型为输出流，可以实现连续输出

二、测试代码（大整数相加与输出测试程序）

类与测试代码（类内定义函数，直接复制可用）

代码如下（示例）：

#include <iostream>
#include <string>
using namespace std;

/* 此处为HugeInteger类的定义和实现 */
class HugeInteger
{
private:
    string integer;               //用string类型储存数值
public:

    HugeInteger(){                //默认为00，其中第一个0为占位符，从第二位开始为数值，输出时可以省略
        integer="00";
    };

    HugeInteger(int a){           //将int类型转化为HugeInteger类型
        string x;
        x=to_string(a);
        integer="0"+x;
    } ;
    HugeInteger(string a){        //将string类型转化为HugeInteger类型
        integer="0"+a;
    };

    HugeInteger operator+(HugeInteger a){       //加法运算符（+）重载，实现HugeInteger类型相加
        HugeInteger INT,max0;
        max0=a;
        INT=*this;

        int Size,Size1,Size2,n=0;

        Size1=INT.integer.size();
        Size2=a.integer.size();

        if (INT.integer.size()>a.integer.size())
        {
            n=1;
            max0=INT;
        };
        if (n==0) Size=Size1;
        else Size=Size2;
        for (int i=0;i<Size;i++)
        {
            int x=0,y=0,z=0;
            x=INT.integer[Size1-i]-'0';     //将那一位对应的字符转换成字符所代表的数字
            y=a.integer[Size2-i]-'0';
            z=x+y;
            x=z%10;
            y=z/10;
            INT.integer[Size1-i]=x+'0';    //将数字转化成字符，再替代此位置字符
            int j=i;
            while(y==1){               //实现加1后连续进位
                if (INT.integer[Size1-j-1]=='9') INT.integer[Size1-j-1] ='0';
                else{
                    INT.integer[Size1-j-1]+=y;
                    y=0;
                }
                j++;
            }
        };

        return INT;
    };
    HugeInteger operator+(int a){     //加法运算符（+）重载，实现HugeInteger类型与int类型相加

        HugeInteger INT(a);           //将int类型转化成HugeInteger类型，再做加法
        INT=*this+INT;
        return INT;
    };
    HugeInteger operator+(string a){  //与上同理
        HugeInteger INT(a);
        INT=*this+INT;
        return INT;
    };

    friend ostream& operator<<(ostream& os,HugeInteger a){      //重载<<符，实现连续输出
        if (a.integer[0]=='0')    //判断首位是否是0，若为0，则从第二位开始输出                        
        {
            int k;
            k=a.integer.size();
            for (int i=1;i<k;i++)
            {
                os<<a.integer[i];
            }
            return os;
        }
        else
        {
            os<<a.integer;
            return os;
        }
    };
};

//此处为测试功能

int main()
{
   HugeInteger n1( 7654321 );
   HugeInteger n2( 7891234 );
   HugeInteger n3( "99999999999999999999999999999" );
   HugeInteger n4( "1" );
   HugeInteger n5;
   cout << "n1 is " << n1 << "\nn2 is " << n2
      << "\nn3 is " << n3 << "\nn4 is " << n4
      << "\nn5 is " << n5 << "\n\n";
   n5 = n1 + n2;
   cout << n1 << " + " << n2 << " = " << n5 << "\n\n";
   cout << n3 << " + " << n4 << "\n= " << ( n3 + n4 ) << "\n\n";
   n5 = n1 + 9;
   cout << n1 << " + " << 9 << " = " << n5 << "\n\n";
   n5 = n2 + "10000";
   cout << n2 << " + " << "10000" << " = " << n5 << endl;

    return 0;
}

以上为全部内容，祝你在学习道路上如履平地 ^_*