用C++实现Bigintger类

最新推荐文章于 2023-05-20 21:17:05 发布
最新推荐文章于 2023-05-20 21:17:05 发布
阅读量519 收藏 1
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51303687/article/details/121150185
版权

前几天受到Java中Biginteger类的启发，自己用C++ 写了一个大整数类，目前功能还很不完善，只支持加、减、乘、比较大小而且不支持负数。代码如下：

/*注意点
 *1.数字存储方式：data[0]为最低位，往后依次升高
 *2.注意0的特殊处理
 */
#ifndef BIGINT_H
#define BIGINT_H
#include <cstring>
#include <string>
#include <algorithm>  //std::reverse
#include <cmath>
#include "Exceptions.h"
#define NUM_GROUP_SIZE 4
#define MOD_BASE 10000
using std::string;
using std::reverse;
using std::min;
using std::max;
using std::bad_exception;

class Biginteger{
  private:
    int *data;
    int eff_len;  //有效长度
    inline bool check(const char *s,int len) {
        for(int i=0; i<len; i++) {
            if(!(s[i]>='0'&&s[i]<='9'))    return 0;
        }
        return 1;
    }
    /*删除前导0*/
    inline int firNoneZero(const char *s,int len) {
        int i;
        for(i=0; i<len-1&&s[i]=='0'; i++);
        return i;
    }
    /*转换为int数组，方便乘法与加法运算*/
    inline void convert(const char *s,int len) {
        int k=0;
        for(int i=len-1; i>=0; i-=NUM_GROUP_SIZE) {
            int now=0;
            for(int j=i-(NUM_GROUP_SIZE-1); j<=i; j++) {
            	if(j<0)	   continue;
                now=now*10+(s[j]-'0');
            }
            data[k++]=now;
        }
    }
    /*处理加法剩下的位数。a为位数较多的数*/
    inline void Add_lefts(const Biginteger &a,Biginteger &res,bool &carry,int minlen) {
        for(int i=minlen; i<a.eff_len; i++) {
            int now=a.data[i]+carry;
            res.data[res.eff_len++]=now%MOD_BASE;
            carry=(bool)(now/MOD_BASE);
        }
    }
    /*求长度*/
    inline void make_length(Biginteger &a) {
        int highest=a.data[a.eff_len-1];
		if(a.eff_len==1&&highest==0)  a.length=1;
        else   a.length=(a.eff_len-1)*NUM_GROUP_SIZE+(int)log10(highest)+1;
    }
    /*处理减法。在此处提供统一接口是因为结果可正可负*/
    Biginteger general_subt(const Biginteger &large,const Biginteger &small) {
        bool tw=0;  //退位
        Biginteger ret(large.length);
        for(int i=0; i<small.eff_len; i++) {
            int now=large.data[i]-small.data[i]-tw;
            if(now<0) {
                tw=1;
                now=MOD_BASE-abs(now);
            }
            else    tw=0;
            ret.data[ret.eff_len++]=now%MOD_BASE;
        }//处理后面几位
        for(int i=small.eff_len; i<large.eff_len; i++) {
            int now=large.data[i]-tw;
            if(now<0) {
                tw=1;
                now=MOD_BASE-abs(now);
            }
            else    tw=0;
            ret.data[ret.eff_len++]=now%MOD_BASE;
        }
        //前导零的特殊处理。注意a==b的特殊情况
        //注意：由于上面统一用位数较多数的位数初始化，所以此处可能不知要删1个
        while(ret.data[ret.eff_len-1]==0&&ret.eff_len>1)    ret.eff_len--;
        make_length(ret);
        return ret;
    }
  public:
    int length; //长度
    Biginteger():data(NULL),eff_len(0),length(0) {}
    
    Biginteger(const char *s) {
        if(s==NULL) throw bad_exception();
        int len=strlen(s);
        if(!check(s,len))    throw NumberFormatException();
        int loc=firNoneZero(s,len);
        length=len-loc;
        eff_len=ceil(length/(double)NUM_GROUP_SIZE);
        data=new int[eff_len]();
        if(strcmp(s,"0")==0)	data[0]=0;
        //注 长度不是原来的字符串长度了
        else    convert(s+loc,length);
    }
   
    Biginteger(string str) {
        char *S=new char[str.length()+1]();
        strcpy(S,str.c_str());
        //placement new
        new(this) Biginteger(S);
    }
   
    Biginteger(int len):eff_len(0),length(0) {
        data=new int[(int)ceil(len/(double)NUM_GROUP_SIZE)]();
    }
      //拷贝构造函数
    Biginteger(const Biginteger &another) {
        eff_len=another.eff_len;
        length=another.length;
        data=new int[another.eff_len]();
        for(int i=0; i<eff_len; i++)    data[i]=another.data[i];
    }
    
    Biginteger& operator=(const Biginteger &another) {
        if (this != &another) {  //加上判断，防止自己赋给自己
            if (data != NULL)    delete data;  //如果原来有数据，则释放数据
            eff_len = another.eff_len;
            length = another.length;
            data = new int[another.eff_len]();
            for (int i = 0; i < eff_len; i++)    data[i] = another.data[i];
        }
        return *this;
    }
    /*比较大小。注意从高位向低位比。*/
    inline int compareTo(const Biginteger &a) {
        int alen=a.eff_len;
        if(eff_len>a.eff_len)    return 1;
        if(eff_len<a.eff_len)    return -1;
        for(int i=alen-1; i>=0; i--) {
            if(data[i]>a.data[i])   return 1;
            else if(data[i]<a.data[i])    return -1;
        }
        return 0;
    }
    bool operator<(const Biginteger &a)  {return this->compareTo(a)==-1;}
    bool operator>(const Biginteger &a)  {return this->compareTo(a)==1;}
    bool operator>=(const Biginteger &a) {return this->compareTo(a)>=0;}
	bool operator<=(const Biginteger &a) {return this->compareTo(a)<=0;}
    bool operator==(const Biginteger &a) {return this->compareTo(a)==0;}
    bool operator!=(const Biginteger &a) {return this->compareTo(a)!=0;}
    Biginteger Add(const Biginteger &a) {
		int minlen=min(eff_len,a.eff_len);
		bool carry=0;  //进位标记
		Biginteger ret(max(length,a.length)+1);  //待返回结果
		for(int i=0; i<minlen; i++) {
            int now=data[i]+a.data[i]+carry;
            ret.data[ret.eff_len++]=now%MOD_BASE;
            carry=(bool)(now/MOD_BASE);
		}
		if(minlen==eff_len)  Add_lefts(a,ret,carry,minlen);
		else    Add_lefts(*this,ret,carry,minlen);
		//处理多余进位
		if(carry!=0)   ret.data[ret.eff_len++]=1;
        make_length(ret);
		return ret;
    }/*注意：拷贝构造函数的引用必须为const引用，因为返回值（拷贝）的函数的结果不能用于参数为普通引用类型的参数*/
    Biginteger operator+(const Biginteger &a) {return Add(a);}
    
    Biginteger Subt(const Biginteger &a) {
        if(compareTo(a)>=0) {
            Biginteger ret(general_subt(*this,a));
            return ret;
        }
        else {
            Biginteger ret(general_subt(a,*this));
            ret.data[ret.eff_len-1]=-ret.data[ret.eff_len-1];
            return ret;
        }
    }
    Biginteger operator-(const Biginteger &a) {return Subt(a);}
    
    Biginteger Multiply(const Biginteger &a) {
        int aLen=a.eff_len;
        Biginteger ret(length+a.length);  //存放结果
        for(int i=0; i<eff_len; i++) {  //本数
            int carry=0;
            for(int j=0; j<aLen; j++) {  //a
                int now=data[i]*a.data[j]+carry+ret.data[i+j];
                carry=now/MOD_BASE;
                ret.data[i+j]=now%MOD_BASE;
            }
            if(carry!=0)    ret.data[i+aLen]=carry;
        }
        ret.eff_len=(int)ceil((length+a.length)/(double)NUM_GROUP_SIZE);  //?
        //去除前导0
        /*if*/while(ret.data[ret.eff_len-1]==0&&ret.eff_len!=1)    ret.eff_len--;
		make_length(ret);
        return ret;
    }
    Biginteger operator*(const Biginteger &a) {return Multiply(a);}
    
    const string toString() {
    	if(data[0]==0&&eff_len==1)    return "0";
    	string ret="";
		int now=0;
		for(int i=0; i<eff_len-1; i++) {
			int now=data[i];
			for(int j=0; j<NUM_GROUP_SIZE; j++) {
				ret.append(1,(now%10)+'0');
				now/=10;
			}
		}
		now=abs(data[eff_len-1]);
		//处理最高位
		while(now>0) {
			ret.append(1,(now%10)+'0');
			now/=10;
		}
		//处理减法结果为负数的情况
		if(data[eff_len-1]<0)	ret+="-";
		reverse(ret.begin(),ret.end());
		return ret;
    }
    ~Biginteger() {
		if(data!=NULL) {
    		delete []data;
    		data=NULL;
		}
	}
};
#endif // BIGINT_H

实现过程中遇到一些问题，在此总结：

  1. 数据存储问题：始终记住data[0]是最低位，往后位数依次升高。
  2. 转为字符串时的问题：如果将data[]的内容转为C风格字符串，需注意不要用一个std::string记录结果最后再return ret.c_str();，因为ret被析构之后转换的指向C风格字符串的指针也不再有效。用string构造也应这样。我采取的是直接转换为std::string。
  3. 接上，转换时除最高位外都要补前导0。转换后，字符串整体进行反转。
  4. 减法和乘法都可能不止出现一个前导0。
  5. 析构函数问题：个人认为比较顽固和隐蔽的一个。为一个Biginteger对象用赋值运算符 = 会出错(调试输出SIGTRAP)，经检查是一个数据被析构两次。问题的根源在于采用=赋值会导致浅拷贝，因此重载这个运算符即可。
m0_51303687
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++通过类实现线性表
08-19
主要为大家详细介绍了C++通过类实现线性表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
用c++实现一个类模板
03-20
国防科技大学大一年级，程序设计（c、c++）课程作业一。实现一个类模板 象征性地收取积分
用类的方式实现C++链表功能
05-29
实现的操作：有头链表； 实现的功能：增，删，改，查； 关于资源：我的文章中有部分解释，相关内容还可查看我的文章； 关于问题：有问题及时私信我，例如不能运行，运行失败等问题；
BigInteger:C ++实现BigInteger
03-28
大整数 C ++实现BigInteger
C++简单集合类的实现方法
09-02
如何使用C++实现一个简单的集合类，这篇文章主要介绍了C++简单集合类的实现方法，感兴趣的小伙伴们可以参考一下
C++ 实现BigInteger 类
Dmaxiya
07-01 9928
本文提供可复用 C++ BigInteger 类的声明与实现，读者可直接复制使用或从 Github 上获取代码，笔者希望能提供“像使用基本数据类型一样方便”的高精度整数类
BigInteger 大整数类（C++）
dragonylee的博客
08-10 998
有时候需要用到大整数，这里放一个自己写的大整数结构体（BigInteger），实现的功能如下： 输入输出； 四则运算； 比较运算； 幂运算； 其中乘法运算和除法运算都是 O(n2)O(n^2)O(n2) 的复杂度。 struct BigInteger { #define SIZE(x) ((int)x.size()) std::vector<int> x; // 从低位往高位存储 bool sign; // 0:+ 1:- // 构造 Big..
C++ 大整数类（无符号BigInteger类和带符号SignedBigInteger类）实现
Gxysbra的博客
10-17 3194
C++ BigInteger类实现，存储任意大小的非负整数 参考 算法竞赛入门经典第二版 5.3 节——大整数类 代码（先放代码，后续追加注释与可以为负数的实现） #include <string> #include <vector> #include <algorithm> #include <iostream> using namespace std; /** * 存储任意大小的非负整数 */ class BigInteger { fr
C++大整数类BigInteger的四则运算
doraJmon的博客
03-28 1918
前言 众所周知，C++莫得高精度，本蒟蒻在网上找到的代码也没有特别成系统的，所以决定自己写个库开心一下~~~ 头文件：BigInteger.h #pragma once #include <iostream> #include <istream> #include <ostream> #include <algorithm> #include &lt...
c++ 大整数库 big integer
10-15
c++ 大整数库 big integer 来自https://mattmccutchen.net/bigint/
C++堆栈类模板实现代码
08-26
主要为大家详细介绍了C++堆栈类模板的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++大数类
chenjun15的博客
12-26 738
我写的大数类
biginteger用法c语言,C++ 大数算术 BigInteger
weixin_32661017的博客
05-22 334
#include "string"using namespace std;class BigInteger{private:string s;string subtraction(string s1, string s2){if (s1 == s2)return "0";while (s1.length() < s2.length())s1 = '0' + s1;while (s2.leng...
C++大数BigInt
Happig的博客
07-24 2608
前言 一直在用板子，然后考虑到有些细节还不是很清楚，就整理一下吧。然后没有按板子来写，但是思想基本一致，因为我的板子是每四位合并成一位，也就是将大数看做一个100001000010000进制数 构造和输出 大数一位位地输入比较慢，因此一般采用字符串输入，然后将字符串转化为大数 注意需要从后向前存，运算时从前向后运算，输出时从后向前输出 const int maxn=1005; struct BigInt{ int a[maxn]; int len; BigInt(){ len=1
大整数类设计（C++）
qq_42731435的博客
01-04 4320
简介 在平时的功能需求中，C/C++语言内置的整形变量表示范围已经足够大了，但是在一些特定的场合，例如解决数学问题的时候，可能需要表示极大的整数。这时候C/C++语言提供的类型就不能满足需求了，需要自己来实现超大整数的实现，当然仅仅是能够存储超大整数还不行，还要能够进行运算。 设计功能 能够表达正数与负数 能够由整形或字符串转化得到 能够使用 + - * / 等符号进行运算 可以与int 类型进行混合运算 可以使用输入输出流 当发生除数为零等错误时会抛出异常 源码分享 头文件：BigInt.h #inc
C++ 创建HugeInteger(大整数)类
weixin_74287172的博客
05-20 1292
提供成员函数input(输)、output(输出)、add(加)和substract(减)。为了比较 HugeInteger 对象，提供函数isEqualTo(是等于)isNotEqualTo(是不等于)、isGreaterThan(是大于)、isLessThan(是小于)、isGreaterThanOrEqualTo(是大于等于)和isLessThanOrEqualTo(是小于等于)，这几个函数每个都是“判定”函数，如果两个HugeInteger对象间关系成立，则返回true;
C++ BigInterger(加减乘除)
wangwei452799的专栏
08-27 1188
  C++ BigInterger(加减乘除)#include #include #include #include #include using namespace std;class DividedByZeroException ...{};class BigInteger...{    private:        vector digits;         bool s
大数类BigInteger,高精度类BigDecimal
Harden13up的博客
07-28 240
这个博客，我只想单纯地说明java,BigInteger和BigDecimal的强大 C++的快速幂取模，在java中可以用BigInteger封装的方法来代替。 BigDecimal实现了高精度的算法，是一个非常强大的类，在java API可以查具体强大的用法，因为用法太多了，在这里就不具体写了    先写一下BigInteger的一个例子： Gdufe_2018_Summer II ...
C++大数模板
xiji333的博客
05-02 430
模板一： #include <cstdio> #include <algorithm> #include <iostream> #include <string> #include <cstring> #include <vector> #include <cctype> using namespace st...
用c++实现一个全局异常类
最新发布
05-26
可以定义一个 `GlobalException` 类，它继承自 `std::exception`，并且重载 `what()` 函数来返回异常信息。 以下是一个示例代码： ```c++ #include #include class GlobalException : public std::exception { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值