【C++】C++大数的运算

一、实验项目内容

(HugeInteger Class) Create a class HugeInteger that uses a 40-element array of digits to store integers as large as 40 digits each.

  1.Provide member functions input, output, add and subtract.
  2.For comparing HugeInteger objects, provide functions isEqualTo, isNotEqualTo, isGreaterThan, isLessThan, isGreaterThanOrEqualTo and isLessThanOrEqualTo — each of these is a “predicate” function that simply returns true if the relationship holds between the two HugeIntegers and returns false if the relationship does not hold.
  3.Also, provide a predicate function isZero.
  4.If you feel ambitious, provide member functions multiply, divide and modulus.

二、实验过程或算法

HugeInteger.h:

#ifndef CIRCLE_H
#define CIRCLE_H
#include <algorithm>
#include <string.h>
using namespace std;

class HugeInteger{
    private:
    char* HugeInteger1;                                  //声明私有成员HugeInteger1
    char* HugeInteger2;                                  //声明私有成员HugeInteger2
//    char* AddNumber;
//    char* SubNumber;
    int compareFlag;                                     //判断标志
    int isEqual=0;                                       //HugeInteger1=HugeInteger2
    int isGreater=1;                                     //HugeInteger1>HugeInteger2
    int isLess=-1;                                       //HugeInteger1<HugeInteger2

public:
    HugeInteger();                                       //构造函数1
    HugeInteger( char* HugeInteger1, char* HugeInteger2);//构造函数2

    char* getAddNumber();                                //加法运算
    char* getSubNumber();                                //减法运算

    char* getHugeInteger1();                             //getter and setter
    void setHugeInteger1(char* hugeInteger1);
    char* getHugeInteger2();
    void setHugeInteger2(char* hugeInteger2);

    bool isEqualTo();                                     //compare
    int isNotEqualTo();                                  //return true or false
    int isGreaterThan();
    int isLessThan();
    int isGreaterThanOrEqualTo();
    int isLessThanOrEqualTo();

    void compare();                                      //比较两数大小的函数

};

#endif

HugeInteger.cpp:

#include "HugeInteger.h"

HugeInteger::HugeInteger(){
    this->HugeInteger1="88888888888888888888888888888888888888888888888888888888888888888888888888";
    this->HugeInteger2="66666666666666666666666666666666666666666666666666666666666666666666666666";

    compare();
}

HugeInteger:: HugeInteger( char* HugeInteger1, char* HugeInteger2){
    this->HugeInteger1=HugeInteger1;
    this->HugeInteger2=HugeInteger2;

    compare();
}

char* HugeInteger::getHugeInteger1(){
    return HugeInteger1;
}
char* HugeInteger::getHugeInteger2(){
    return HugeInteger2;
}

void HugeInteger::setHugeInteger1(char* hugeInteger1){
    this->HugeInteger1=HugeInteger1;
}
void HugeInteger::setHugeInteger2(char* hugeInteger2){
    this->HugeInteger1=HugeInteger2;
}

void HugeInteger::compare(){
    int lHugeInteger1=strlen(HugeInteger1), lHugeInteger2=strlen(HugeInteger2);
    if(lHugeInteger1>lHugeInteger2){                       //HugeInteger1的位数大于HugeInteger2，则HugeInteger1大
        compareFlag=isGreater;
    }
    else if(lHugeInteger1<lHugeInteger2){                  //HugeInteger1的位数小于HugeInteger2,则HugeInteger1小
        compareFlag=isLess;
    }
    else{                                                  //位数相等
        char* pHugeInteger1 = HugeInteger1;
        char* pHugeInteger2 = HugeInteger2;

        for(int c=0;c<lHugeInteger1;c++){                  //依次比较每一位数的大小
            if((*pHugeInteger1)>(*pHugeInteger2)){         //不等，则比较大小
                compareFlag=isGreater;
                break;
            }
            else if((*pHugeInteger1)<(*pHugeInteger2)){
                compareFlag=isLess;
                break;
            }
            else{                                          //相等继续
                continue;
            }
        }
    }
}

char* HugeInteger::getAddNumber() {
    int maxlen = max(strlen(HugeInteger1), strlen(HugeInteger2));
    //多两个字符，一个是结束符'/0'，另一个保存当两个数最高位相加后有进位的情况
    char* p = new char[maxlen + 2];
    //结束符
    *(p + maxlen + 1) = '\0';
    //声明两个指针分别指向HugeInteger1和HugeInteger2的末尾，不含结束符
    char* pHugeInteger1 = HugeInteger1 + strlen(HugeInteger1) - 1;
    char* pHugeInteger2 = HugeInteger2 + strlen(HugeInteger2) - 1;
    int m = 0;
    int n = 0;
    //进位
    int c = 0;
    for (int i = maxlen; i > 0; i--) {
        m = n = 0;
        //因为当pHugeInteger1到达第一个字符时，即pHugeInteger1=a时，也要进行计算，所以这里用(pHugeInteger1-1)来判断
        //'0'的Asic是48，减去48转成数字
        if ((pHugeInteger1 + 1) != HugeInteger1) {
            m = *pHugeInteger1 - 48;
            pHugeInteger1--;
        }
        if ((pHugeInteger2 + 1) != HugeInteger2) {
            n = *pHugeInteger2 - 48;
            pHugeInteger2--;
        }
        //为p指针的第i个字符赋值
        *(p + i) = (m + n + c) % 10 + 48;
        //取得进位
        c = (m + n + c) / 10;
    }
    *p = 48 + c;

    if(*p=='0'){                        //如果结果的第一位是‘0’，表示没有进位
        return p+1;                     //返回第二位的指针，以去除第一位多余的0
    }
    return p;
}
char* HugeInteger::getSubNumber(){

    int isNegative=0;                   //定义结果是否为负数的标志，初始为0,不是负数

    if(compareFlag==isLess){            //如果HugeInteger1小于HugeInteger2,置换两数
        char* temp=HugeInteger1;
        HugeInteger1=HugeInteger2;
        HugeInteger2=temp;

        isNegative=1;                   //结果为负
    }

    int maxlen = max(strlen(HugeInteger1), strlen(HugeInteger2));
    //应为HugeInteger1始终大于HugeInteger2,不考虑被减数最高位不够减的情况
    char* p = new char[maxlen + 1];
    //最后一位是结束符
    *(p + maxlen) = '\0';
    //声明两个指针分别指向HugeInteger1和HugeInteger2的末尾，不包含结束符
    char* pHugeInteger1 = HugeInteger1 + strlen(HugeInteger1) - 1;
    char* pHugeInteger2 = HugeInteger2 + strlen(HugeInteger2) - 1;
    int m = 0;
    int n = 0;
    //借位位
    int c = 0;
    for (int i = maxlen - 1; i >=0; i--) {
        m = n = 0;
        //'0'的Asic是48，减去48转成数字
        if ((pHugeInteger1 + 1) != HugeInteger1) {
            m = *pHugeInteger1 - 48;
            pHugeInteger1--;
        }
        if ((pHugeInteger2 + 1) != HugeInteger2) {
            n = *pHugeInteger2 - 48;
            pHugeInteger2--;
        }
        //不够减，要借位
        if (m < n) {
            //为p指针的第i个字符赋值
            *(p + i) = 10 + m - n - c + 48;
            c = 1;
        } else {
            //虽然够减，但是如果再算是借走的一位，那么就小于0了
            if (m - n - c < 0)
                *(p + i) = 10 + m - n - c + 48;
            else {
                *(p + i) = m - n - c + 48;
                c = 0;
            }
        }
    }
    if (isNegative == 1) {
        if (*p == '0') {                        //如果结果的第一位是‘0’，表示没有进位
            char* temp = new char[maxlen];
            temp = p + 1;                            //返回第二位的指针，以去除第一位多余的0
            char* newp = new char[maxlen + 1];
            *newp = '-';                             //首地址带符号‘-’
            for (int i = 0; i < maxlen; i++) {
                *(newp + 1 + i) = *(temp+i);
            }
            return newp;                          //返回带符号的新字符串
        }
        else {
            char* temp2 = new char[maxlen+1];
            temp2 = p ;
            char* newp2 = new char[maxlen +2];
            *newp2 = '-';                             //首地址带符号‘-’
            for (int i = 0; i < maxlen+1; i++) {
                *(newp2 + 1 + i) = *(temp2+i);
            }
            return newp2;                          //返回带符号的新字符串
        }
    }
    else {
        if (*p == '0') {                        //如果结果的第一位是‘0’，表示没有进位
            return p+1;                     //返回第二位的指针，以去除第一位多余的0
        }
        return p;
    }
}

int HugeInteger::isGreaterThan(){
    if(compareFlag==isGreater){
        return true;
    }
    else{
        return false;
    }
}
int HugeInteger::isLessThan(){
    if(compareFlag==isLess){
        return true;
    }
    else{
        return false;
    }
}
bool HugeInteger::isEqualTo(){
    if(compareFlag==isEqual){
        return true;
    }
    else{
        return false;
    }
}
int HugeInteger::isNotEqualTo(){
    if(compareFlag==isEqual){
        return false;
    }
    else{
        return true;
    }
}
int HugeInteger::isGreaterThanOrEqualTo(){
    if(compareFlag==isLess){
        return false;
    }
    return true;
}
int HugeInteger::isLessThanOrEqualTo(){
    if(compareFlag==isGreater){
        return false;
    }
    return true;
}

测试类：

#include <iostream>
#include "HugeInteger.h"
#include <string>

using namespace std;

int main() {
    string hugeInt1,hugeInt2;                      //声明两个string来存储HugeIntegers

    cout<<"please enter the first hugeInteger :";   //输入HugeIntegers
    cin>>hugeInt1;
    cout<<"please enter the second hugeInteger:";
    cin>>hugeInt2;

    const char* a =hugeInt1.c_str();                //sting转换成char*
    const char* b =hugeInt2.c_str();
/*
    HugeInteger hugeInteger1;                       //HugeInteger默认构造函数
    cout << hugeInteger1.getAddNumber() << endl;    //
    cout << hugeInteger1.getSubNumber() << endl;
*/

    HugeInteger hugeInteger((char*)a,(char*)b);    //声明一个hugeInteger的object
                                                   //输出原始数据
    cout <<"The first hugeInteger is :"<<hugeInteger.getHugeInteger1() << endl;
    cout <<"The second hugeInteger is:"<<hugeInteger.getHugeInteger2() << endl;

    cout <<"\n";                                    //输出相加相减结果
    cout <<"The AddNumber is:"<<hugeInteger.getAddNumber() << endl;
    cout <<"The SubNumber is:"<<hugeInteger.getSubNumber() << endl;

    cout <<"\n";
    cout << "isEqualTo:"<<hugeInteger.isEqualTo()<< endl;      //输出比较大小的结果
    cout << "isGreaterThan:"<<hugeInteger.isGreaterThan()<< endl;
    cout << "isGreaterThanOrEqualTo:"<<hugeInteger.isGreaterThanOrEqualTo()<< endl;
    cout <<"isLessThan:"<< hugeInteger.isLessThan()<< endl;
    cout << "isLessThanOrEqualTo:"<<hugeInteger.isLessThanOrEqualTo()<< endl;
    cout << "isNotEqualTo:"<<hugeInteger.isNotEqualTo()<< endl;

    return 0;
}

三、实验结果和截图