完全正负大数模板（正负数加减乘除求模运算）~~~~~

最新推荐文章于 2020-10-13 10:47:00 发布
最新推荐文章于 2020-10-13 10:47:00 发布
阅读量688 收藏 1
点赞数 2
CC 4.0 BY-SA版权
分类专栏： ACM/ICPC 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_36398723/article/details/78529220
这个博客分享了一种经过改进的ACM大整数运算模板，原模板来自kuangbin，现支持有符号大整数的加减乘除及求模运算。博主针对强迫症进行了细致的修改，并提供了加减法的特殊处理和大整数除法。模板已通过部分测试，欢迎指出潜在问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原模板是从kuangbin的acm模板里copy过来的，根据博主的代码风格对于模板做了一些写法上的小调整，不过呢~

因为博主本人有强迫症（ACMer通病）~~~所以经过一个下午+晚上的修改，将原来只支持无符号大整数的运算改成了支持有符号大整数的运算~~乘法除法挺好修改的，对于新的加法减法写了两个只支持无符号大数的加减法，根据运算符两边的符号位决定运算方式~~~顺便加上了大整数之间的除法运算和几个比较运算符~

模板检查了些许遍，应该没有啥bug了，除了输入-0(本来就不应该吗~)~~~~(有发现的童鞋一定要戳我~~~)

检验状况：


附上模板吧

//Copy from kuangbin~,modify by Siryuanshao
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cstdio>
#include <cstring>
#define MAXN 999999999
#define MAXSIZE 5000
#define DLEN 9
using namespace std;
class BigInt
{
    private:
        int a[500];
        int len;
        bool sign;
        //sign表示符号位的正负~
    protected:
        BigInt add(const BigInt&,const bool)const;
        BigInt subtract(const BigInt&,const bool)const;
         //两个无符号整形的加减法,flag标明结果的符号位~~
    public:
        BigInt() {sign=false;len=1;memset(a,0,sizeof(a));}
        BigInt(const int);
        BigInt(const char*);
        BigInt(const BigInt&);
        BigInt& operator=(const BigInt&);
        friend istream& operator>>(istream&,BigInt&);
        friend ostream& operator<<(ostream&,const BigInt&);
        friend BigInt abs(const BigInt&);

        BigInt operator+(const BigInt&)const;
        BigInt operator-(const BigInt&)const;
        BigInt operator*(const BigInt&)const;
        BigInt operator/(const BigInt&)const;
        BigInt operator/(const int&)const;

        BigInt operator^(const int&)const;
        int operator%(const int&)const;
        bool operator<(const BigInt&)const;
        bool operator>(const BigInt&)const;
        bool operator<=(const BigInt&)const;
        bool operator>=(const BigInt&)const;
        bool operator==(const BigInt&)const;

        inline int size() {return DLEN*(len-1)+to_string(a[len-1]).size();}
};
//对于负数的处理~~~
BigInt::BigInt(const int b)
{
    int c,d=abs(b);
    len=0;
    sign=b<0;
    memset(a,0,sizeof(a));
    while(d>MAXN)
    {
        c=d-(d/(MAXN+1))*(MAXN+1);
        d=d/(MAXN+1);
        a[len++]=c;
    }
    a[len++]=d;
}
BigInt::BigInt(const char *in)
{
    const char *s;
    if(in[0]=='-') s=in+1,sign=true;
    else s=in,sign=false;
    int t,k,index,L,i;
    memset(a,0,sizeof(a));
    L=strlen(s);
    len=L/DLEN;
    if(L%DLEN) len++;
    index=0;
    for(i=L-1;i>=0;i-=DLEN)
    {
        t=0;
        k=i-DLEN+1;
        if(k<0) k=0;
        for(int j=k;j<=i;j++)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}
BigInt::BigInt(const BigInt& T):len(T.len),sign(T.sign)
{
    memset(a,0,sizeof(a));
    for(int i=0;i<len;i++)
        a[i]=T.a[i];
}
BigInt& BigInt::operator=(const BigInt& n)
{
    sign=n.sign;
    len=n.len;
    memset(a,0,sizeof(a));
    for(int i=0;i<len;i++)
        a[i]=n.a[i];
    return *this;
}
//MDZZ~不是和字符串转化为BigInt一样么,233333
istream& operator>>(istream& in,BigInt& b)
{
    char ch[MAXSIZE];
    in>>ch;
    b=BigInt(ch);
    return in;
}
ostream& operator<<(ostream& out,const BigInt& b)
{
    out<<(b.sign?"-":"")<<b.a[b.len-1];
    for(int i=b.len-2;i>=0;i--) out<<setw(DLEN)<<setfill('0')<<b.a[i];
    return out;
}
BigInt abs(const BigInt& T)
{
    BigInt t(T);
    t.sign=false;
    return t;
}
BigInt BigInt::add(const BigInt& T,const bool flag)const
{
    BigInt t(*this);
    t.sign=flag;
    int big;
    big=T.len>len?T.len:len;
    for(int i=0;i<big;i++)
    {
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN)
        {
            t.a[i+1]++;
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0) t.len=big+1;
    else t.len=big;
    return t;
}
BigInt BigInt::subtract(const BigInt& T,const bool flag)const
{
    BigInt t(*this);
    t.sign=flag;
    for(int i=0;i<t.len;i++)
    {
        if(t.a[i]<T.a[i])
        {
            //模拟借位运算过程~
            int j=i+1;
            while(t.a[j]==0) j++;
            t.a[j--]--;
            while(j>i) t.a[j--]+=MAXN;
            t.a[i]+=MAXN+1-T.a[i];
        }
        else t.a[i]-=T.a[i];
    }
    while(t.a[t.len-1]==0&&t.len>1) t.len--;
    return t;
}
BigInt BigInt::operator+(const BigInt& T)const
{
    BigInt ret;
    if(sign^T.sign)
    {
        BigInt t1(*this),t2(T);
        if(abs(t1)<abs(t2)) swap(t1,t2);
        ret=t1.subtract(t2,t1.sign);
        if(ret.a[ret.len-1]==0&&ret.len==1) ret.sign=false;
    }
    else ret=this->add(T,sign);
    return ret;
}
BigInt BigInt::operator-(const BigInt& T)const
{
    BigInt ret;
    if(sign^T.sign) ret=this->add(T,sign);
    else
    {
        BigInt t1(*this),t2(T);
        bool sn;
        if(abs(t1)<abs(t2))
        {
            sn=t1.sign^1;
            swap(t1,t2);
        }
        else sn=t1.sign;
        ret=t1.subtract(t2,sn);
        if(ret.a[ret.len-1]==0&&ret.len==1) ret.sign=false;
    }
    return ret;
}
BigInt BigInt::operator*(const BigInt& T)const
{
    BigInt ret;
    long long up;
    long long temp,temp1;
    for(int i=0;i<len;i++)
    {
        up=0;
        for(int j=0;j<T.len;j++)
        {
            temp=(long long)a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN)
            {
                temp1=temp%(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            }
            else
            {
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0) ret.a[i+T.len]=up;
    }
    ret.sign=sign^T.sign;
    ret.len=len+T.len;
    while(ret.a[ret.len-1]==0&&ret.len>1) ret.len--;
    return ret;
}
BigInt BigInt::operator/(const BigInt& T)const
{
    BigInt r(*this),ret(0);
    while(r>=T)
    {
        BigInt down(1);
        while(r-T*down>=0) down=down*10;
        down=down/10;
        r=r-T*down;
        ret=ret+down;
    }
    ret.sign=sign^T.sign;
    return ret;
}
BigInt BigInt::operator/(const int &b)const
{
    BigInt ret;
    bool sign1=b<0;
    long long down=0;
    for(int i=len-1;i>=0;i--)
    {
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-(long long)ret.a[i]*b;
    }
    ret.sign=sign^sign1;
    ret.len=len;
    while(ret.a[ret.len-1]==0&&ret.len>1) ret.len--;
    return ret;
}
int BigInt::operator%(const int &b)const
{
    int d=0;
    for(int i=len-1;i>=0;i--)
        d=(((long long)d*(MAXN+1))%b+a[i])%b;
    return sign?-d:d;
}
BigInt BigInt::operator^(const int &n)const
{
    BigInt ret(1),t(*this);
    int m=n;
    while(m)
    {
        if(m&1) ret=ret*t;
        t=t*t;
        m>>=1;
    }
    return ret;
}
bool BigInt::operator<(const BigInt& T)const
{
    if(sign&&!T.sign) return true;
    if(!sign&&T.sign) return false;
    //只有sign相同才能作比较~~
    if(len!=T.len) return sign^(len<T.len);
    for(int ln=len-1;ln>=0;ln--)
        if(a[ln]!=T.a[ln]) return sign^(a[ln]<T.a[ln]);
    return false;
}
bool BigInt::operator>(const BigInt& T)const
{
    return T<*this;
}
bool BigInt::operator<=(const BigInt& T)const
{
    if(*this==T) return true;
    return *this<T;
}
bool BigInt::operator>=(const BigInt& T)const
{
    return T<=*this;
}
bool BigInt::operator==(const BigInt& T)const
{
    if(sign!=T.sign||len!=T.len) return false;
    for(int i=len-1;i>=0;i--)
        if(a[i]!=T.a[i]) return false;
    return true;
}


大数加法（包括负数）
Sharpen_ice的博客
07-24 515
#include <iostream> using namespace std; int main(void){ string a,b; int aa[1002]={0}; int bb[1002]={0}; int sum[1002]; int len_a=0; int len_b=0; while(cin>>...
[ACM模板] BigInt高精度加/减/除法
vcvycy的专栏
10-03 927
/* 做了一些优化，试了试，高精度乘法只比普通long long乘法慢6倍*/#include #include #include using namespace std; class BigInt{ //无符号整数高精度 #define MAXDIGIT 10000 //最大为10^MAXDIGIT #define BIGINTMOD 10000 //压4位 private: public
ACM大数模板（支持正负整数）
weixin_30787531的博客
10-01 177
之前就保留过简陋的几个用外部数组变量实现的简单大数模板，也没有怎么用过，今天就想着整合封装一下，封装成C++的类，以后需要调用的时候也方便得多。 实现了基本的加减乘除和取模运算的操作符重载，大数除以大数难度太大就没实现，另外还实现了比较运算符，方便实际使用贴近内置类型的体验。 话不多说，贴代码。 /*BigInt.h*/ 1 #include <stdi...
大数减法（正负数均可）
06-03
大数减法 （目前可支持100位，可以修改） （正负数均可）
C++可正负大数类模板
02-15
C++大整数类,支持正负，支持比较运算，加减乘自加自减自乘等操作。
大数加法模板
辰风的博客
07-12 344
大数加法模板。 #include<iostream> #include<string> using namespace std; int main() { string sum(string s1,string s2); string s1,s2; // cin>>s1>>s2; while...
51nod 1005 大数加法（可为负数）
liuyanfeier的专栏
05-20 1347
给出2个大整数A,B，计算A+B的结果。 Input 第1行：大数A 第2行：大数B (A,B的长度  Output 输出A + B 没什么思路，就是转化为字符串之后模拟。 #include #include #include #include using namespace std; int cons
功能最全带正负,代码简洁150行的---ACM大数四则运算模板
qq_41046771的博客
04-14 295
BigNum类封装了所有的功能: 包括输入intput(),输出prin(),还有+-*/ ,其中的+-*/还涵盖了左操作数和右操作数正负与大小的所有情况 另外还附带封装了两个数字之间进行比较的辅助函数 里面包含了2个宏定义,RE表示循环和PB表示push_back 求赞,希望转载要带原地址 #include<iostream> #include<vec...
大数运算支持负数但是不支持大数除以大数
cquzhengdayday的博客
11-29 429
includeincludeincludeusing namespace std; const int maxn = 5000; class BigInt { private: int bit[5000]; bool negative;//负数标志public: BigInt(); //默认构造函数，值为0 BigInt(c
大数加减法 C语言 包含负数
梦
04-18 3695
#define _CRT_SECURE_NO_WARNINGS #include #define MAXSIZE 10 void Add(char a[], char b[], char c[]); void Sub(char a[], char b[], char c[]); int Get_len(char a[]); bool Max_a(char a[], char b[]);
大数四则运算（带小数及正负号），附PI计算
10-12
本程序用VC++6.0平台运行通过，对PI求值运算算到了350位，并可进一步运算，但效率一般
正负数移位运算规则
weixin_44895142的博客
10-13 2942
移位运算【<<(左移)、>>>(带符号右移)、>>>(无符号右移) 】 << 规则： 按二进制形式把所有的数字向左移动对应的位数，高位移出(舍弃)，低位的空位补零。 语法格式： 意义： 在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方。 >> 规则： 按二进制形式把所有的数字向右移动对应的位数，低位移出(舍弃)，高位的空位补符号位，即正数补零，负数补1。 意义： 右移一位相当
jquery中对于数字的计算
戈多
10-21 4219
Jquery 对数字进行向上取整，向下取整，四舍五入等计算： /** * 抹零方式 * 0：不抹零, 1：四舍五入（元）,2：逢一进十（元）,3：舍位取整（元） * 4：四舍五入（角）,5：逢一进十（角）,6：舍位取整（角）,7：自由处理 */ function roundWay(roundWay){ var x = $('#totalAmount_id').val();//费用总额
数字电路模2运算原理，及模2的加减乘除详解
04-28 5661
模2运算的原理（转） 模2运算是一种二进制算法，CRC校验技术中的核心部分，因此，我们在分析CRC算法之前，必须掌握模2运算的规则。与四则运算相同，模2运算也包括模2加、模2减、模2乘、模2除四种二进制运算。而且，模2运算也使用与四则运算相同的运算符，即“＋”表示模2加，“－”表示模2减，“×”或“·”表示模2乘，“÷”或“/”表示模2除。与四则运算不同的是模2运算不
正负数的移位运算
dajiangyou123456的博客
06-12 363
正负数的移位运算 正数左移、右移都是在另一端添加相应个数的0； 而负数左移是在右端添加相应个数的0，右移是在左端添加相应个数的1；
利用位运算判断整数的正负
likecool21的专栏
04-20 7384
挺有趣的题：给定一个整数，判断其正负，正数返回1，复数返回-1，0返回0.要求只能用位运算符和加号，且不能用循环判断等控制语句。 想到的代码是类似递归的，感觉还是挺笨的： int sign(int x) { //Right move 31 bits, if x is non-negative, then a=0x00000000 //if x is negative, then a =
大数的加减法操作（C代码）
lj779323436的博客
04-25 813
网上有关大数加减法操作的代码多是不带符号进行运算的，自己写了一个带符号的版本，供学习和参考，代码里面注释很详细，直接上代码 #include <stdio.h> #include <string.h> #define M 100 //定义了数量M是100作为数组初始化的数量 typedef struct bigint{ char num[M]; int symbo...
二进制 正负数加减法 计算INT_MIN - 1=INT_MAX
热门推荐
NO0111的博客
08-27 1万+
首先得知道，在java中,int类型占4个字节，1个字节等于8位二进制，所以int类型32位,范围是-2147483648到2147483647， 因为1000 0000, 0000 0000, 0000 0000, 0000 0000这个是-2^31=-2147483648，所以负数多一个。 然后，因为计算机CPU的运算器中只有加法器，所以减法要转化成加法来计算，所以引入了补码。 补码可以
AOE算法——超详细，超通俗讲解
Maybemust的博客
08-22 4323
AOE算法应用和实现思路讲解可以参见其他数据结构教材或者网上相关博客文章，在这里，我就具体针对代码讲解具体含义： 首先是类头文件：#pragma once #define maxsize 100 #define MAX 999999999 class graph {public: //活动数量 int possize; //邻接矩阵存储图 int store[maxs
C++实现大数运算类：加减乘除与运算符重载
"本文介绍了一种在C++中实现大数加减乘除的类设计方法，包括大数的存储、输入输出、比较操作以及基本的算术运算符重载。" 在C++编程中，处理大数（超出普通整型变量范围的数字）时，通常需要自定义数据结构和算法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值