大数模板——来自jxy师兄

#include <iostream>
#include <cstring>
#include <cstdio>
#define MAX 1300
#define base 10000
#define baselen 4
using namespace std;
//int countnub = 0;
//此大整数类用数组 digital[MAX]表示一个大整数;
//一个 digital表示最大为 9999;
//len 表示目前整数的用到最大digital位,sign表示符号;
class Int
{
public :
    //构造函数;
    Int();
    //比较函数,第二个参数为 0则表示绝对值比较;
    int cmp(Int  ,int);
    //判断是否为0;
    bool zero();
    //判定奇偶性;
    bool odd();
    //右移一个二进制位
    Int move();
    //赋值;
    Int operator = (int);
    Int operator = (Int );
    Int operator = (char*);
    //双目运算;
    Int operator +(Int );
    Int operator -(Int );
    Int operator *(Int );
    Int operator /(Int );
    Int operator %(Int );
    //输入输出;
    friend ostream& operator <<(ostream&,Int );
    friend istream& operator >>(istream& ,Int& );
private :
    int digital[MAX];
    int sign;
    int len;
    //十进制移位
    Int shift(int k);
};

Int ::Int()
{
    digital[len=0] = 0, sign = 1;
}

int Int::cmp(Int obj, int sel = 1)//sel若初始为0是绝对值比较
{
    if(sel&&obj.sign+sign == 0)return sign - obj.sign;  //比较正负号;
    int k = len - obj.len;//比较长度;
    if(k)return sel? sign*k : k;
    for(k = len; k>0 && obj.digital[k] == digital[k]; k--);  //比较数位;
    return sel? sign * ( digital[k] - obj.digital[k] ): digital[k]-obj.digital[k];
}

bool  Int::zero()
{
    return digital[0]+len ==0;
}

bool  Int:: odd()
{
    return digital[0]&1;
}

Int  Int::move()
{
    if(digital[0]<=1&&len==0)digital[0] = 0;
    else
    {
        int k = len , t, carry=0;
        if (digital[len]==1)len--;
        while(k>=0)
        {
            t = digital[k]&1;
            digital[k]= digital[k]>>1;
            if(carry)digital[k] += base/2;
            k--;
            carry = t;
        }
    }
    if(this->zero())sign = 1;
    return *this;
}
///
Int Int::operator =(Int obj)
{
    for(len = 0, sign = obj.sign; len <= obj.len; len++)digital[len]=obj.digital[len];
    len--;
    return *this;
}
Int Int::operator = (int obj)
{
    if(obj<0)sign = -1, obj = -obj;
    else sign = 1;
    digital[0] = obj%base;
    if(obj/=base)
    {
        digital[1] = obj%base, len = 1;
        if(obj/=base)digital[2] = obj%base, len = 2;
    }
    else len = 0;
    return *this;
}
Int Int::operator =  (char *s)
{
    int i, j, l, k;
    if(s[0] == '-')l = 1,sign = -1;
    else l = 0, sign = 1;
    i=l;
    while(s[i])i++;
    i--;
    k=0;
    while(i-baselen+1>=l)
    {
        for(j=1,digital[k]=0; j<=baselen; j++)
            digital[k]=digital[k]*10+s[i-baselen+j]-'0';
        i = i-baselen,k++;
    }
    digital[k] = 0;
    while(i>=l)digital[k] = digital[k]*10 + s[l++] - '0';
    if(k)len = k-(digital[k]==0);
    else len = 0;
    return *this;
}
/
Int Int::operator +(Int obj)
{
    Int sum;
    if(obj.sign==sign)   //同号加;
    {
        int carry;
        int i;
        for(i = carry = 0; i <= len && i <= obj.len; i++)
            carry  =  carry  + digital[i]  + obj.digital[i],  sum.digital[i]    =  carry%base,
                      carry = carry/base;
        for(; i <= len; i++)
            carry  =  carry  +  digital[i],  sum.digital[i]    =  carry%base,  carry  =
                          carry/base;
        for(; i <= obj.len; i++)
            carry  =  carry  +obj.digital[i],  sum.digital[i]    =  carry%base,  carry  =
                          carry/base;
        sum.len = i-!(sum.digital[i] = carry);
        sum.sign = sign;
        return sum;
    }
    else    //异号变同号减法;
    {
        sum = obj;
        sum.sign = -sum.sign;
        return *this-sum;
    }
}
Int  Int::operator -(Int obj)
{
    Int *sub1, *sub2, quotient;
    if(sign==obj.sign)   //同号减;
    {
        int i, carry;
        i = this->cmp(obj,0);//绝对值比较;
        if(i==0)return quotient;
        else if(i<0)sub1 = &obj, sub2 = this, quotient.sign = -sign;
        else sub1 = this, sub2 = &obj, quotient.sign = sign;
        for(i = carry = 0; i <= sub2->len; i++)
            if(  (quotient.digital[i] = sub1 ->digital[i] - carry - sub2->digital[i]) < 0)
                carry = 1, quotient.digital[i] += base;//借位;
            else carry = 0;
        for(; i <= sub1->len; i++)
            if(  (quotient.digital[i]  =  sub1  ->digital[i]  -  carry  )<  0  )carry  =  1,
                        quotient.digital[i] += base;//借位;
            else carry = 0;
        i--;
        while(i&"ient.digital[i]==0)i--;
        quotient.len = i;
        return quotient;
    }
    else      //异号变同号加:
    {
        quotient = obj, quotient.sign = -obj.sign;
        return *this + quotient;
    }
}
Int Int::operator *(Int obj)
{
    int carry, i, j, maxlen;
    Int product;
    maxlen = obj.len + len + 2;
    memset( product.digital, 0, sizeof(int)*maxlen );
    for(i = 0; i <= obj.len; i++)
    {
        for(j =0, carry = 0; j <= len; j++)
        {
            carry += obj.digital[i] * digital[j] +product.digital[j+i];
            product.digital[j+i] = carry%base;
            carry/=base;
        }
        while(carry) product.digital[i+j++] = carry%base, carry /= base;
    }
    i = maxlen-1;
    while(i&&product.digital[i]==0)i--;
    product.len = i;
    if(product.zero())product.sign = 1;//确定符号
    else product.sign = sign*obj.sign;
    return product;
}
Int Int::operator /( Int obj)
{
    int div,    k,   flag;
    Int x, y, z;
    x = *this;
    flag = obj.sign*sign;
    obj.sign = x.sign = 1;
    while( x.cmp(obj) >0 )
    {
        k = x.len-obj.len;
        if(  x.digital[x.len]  >  obj.digital[obj.len]  )  div  =
                x.digital[x.len]/(obj.digital[obj.len]+1);
        else  if(x.len>obj.len)k--,  div  =
                (x.digital[x.len]*base+x.digital[x.len-1])/(obj.digital[obj.len]+1);
        else break;
        x = x - ( obj*(z=div) ).shift(k);
        y = y+ z.shift(k);
    }
    if(x.cmp(obj)>=0)y = y+(z=1);
    if(y.zero())y.sign=1;
    else y.sign=flag;
    return y;
}
Int Int::operator %(Int obj)
{
    int div,   k;
    Int x, y, z;
    x = *this;
    obj.sign = x.sign = 1;
    while( x.cmp(obj) >0 )
    {
        k = x.len-obj.len;
        if(  x.digital[x.len]  >  obj.digital[obj.len]  )  div  =
                x.digital[x.len]/(obj.digital[obj.len]+1);
        else  if(x.len>obj.len)k--,  div  =
                (x.digital[x.len]*base+x.digital[x.len-1])/(obj.digital[obj.len]+1);
        else break;
        x = x - ( obj*(z=div) ).shift(k);
    }
    if(x.cmp(obj)>=0)x = x-obj;
    if(x.zero())x.sign = 1;
    else x.sign = sign;
    return x;
}
Int Int::shift(int k)
{
    Int temp;
    int i;
    temp = *this;
    for(i=0; i<=len; i++)temp.digital[i+k]=digital[i];
    for(i=0; i<k; i++)temp.digital[i] = 0;
    temp.sign = sign;
    temp.len = len+k;
    return temp;
}
///
ostream& operator <<(ostream& out,Int obj )
{
    int i = obj.len;
    if(obj.sign==-1)out<<'-';
    out<<obj.digital[i--];
    out.fill('0');
    out.setf(ios::right);
    while(i>=0)
    {
        out.width(baselen);
        out<<obj.digital[i--];
    }
    return out;
}
istream& operator >>(istream& in,Int& obj)
{
    char s[baselen*MAX];
    in>>s;
    obj = s;
    return in;
}
int main()
{
    Int a, b;
    while(cin >> a >> b)
    {
        cout << a+b << endl;
        cout << a-b << endl;
        cout << a*b << endl;
        cout << a/b << endl;
    }
    return 0;
}



                
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言(也称为Golang)是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言,特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势: 简洁性:Go语言的语法简单直观,易于学习和使用。它避免了复杂的语法特性,如继承、重载等,转而采用组合和接口来实现代码的复用和扩展。 高性能:Go语言具有出色的性能,可以媲美C和C++。它使用静态类型系统和编译型语言的优势,能够生成高效的机器码。 并发性:Go语言内置了对并发的支持,通过轻量级的goroutine和channel机制,可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性:Go语言具有强大的类型系统和内存管理机制,能够减少运行时错误和内存泄漏等问题。它还支持编译时检查,可以在编译阶段就发现潜在的问题。 标准库:Go语言的标准库非常丰富,包含了大量的实用功能和工具,如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现,而无需花费太多时间在底层功能的实现上。 跨平台:Go语言支持多种操作系统和平台,包括Windows、Linux、macOS等。它使用统一的构建系统(如Go Modules),可以轻松地跨平台编译和运行代码。 开源和社区支持:Go语言是开源的,具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之,Go语言是一种简单、高效、安全、并发的编程语言,特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言,并且需要处理大量的并发请求和数据,那么Go语言可能是一个不错的选择。
Go语言(也称为Golang)是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言,特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势: 简洁性:Go语言的语法简单直观,易于学习和使用。它避免了复杂的语法特性,如继承、重载等,转而采用组合和接口来实现代码的复用和扩展。 高性能:Go语言具有出色的性能,可以媲美C和C++。它使用静态类型系统和编译型语言的优势,能够生成高效的机器码。 并发性:Go语言内置了对并发的支持,通过轻量级的goroutine和channel机制,可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性:Go语言具有强大的类型系统和内存管理机制,能够减少运行时错误和内存泄漏等问题。它还支持编译时检查,可以在编译阶段就发现潜在的问题。 标准库:Go语言的标准库非常丰富,包含了大量的实用功能和工具,如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现,而无需花费太多时间在底层功能的实现上。 跨平台:Go语言支持多种操作系统和平台,包括Windows、Linux、macOS等。它使用统一的构建系统(如Go Modules),可以轻松地跨平台编译和运行代码。 开源和社区支持:Go语言是开源的,具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之,Go语言是一种简单、高效、安全、并发的编程语言,特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言,并且需要处理大量的并发请求和数据,那么Go语言可能是一个不错的选择。
Go语言(也称为Golang)是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言,特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势: 简洁性:Go语言的语法简单直观,易于学习和使用。它避免了复杂的语法特性,如继承、重载等,转而采用组合和接口来实现代码的复用和扩展。 高性能:Go语言具有出色的性能,可以媲美C和C++。它使用静态类型系统和编译型语言的优势,能够生成高效的机器码。 并发性:Go语言内置了对并发的支持,通过轻量级的goroutine和channel机制,可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性:Go语言具有强大的类型系统和内存管理机制,能够减少运行时错误和内存泄漏等问题。它还支持编译时检查,可以在编译阶段就发现潜在的问题。 标准库:Go语言的标准库非常丰富,包含了大量的实用功能和工具,如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现,而无需花费太多时间在底层功能的实现上。 跨平台:Go语言支持多种操作系统和平台,包括Windows、Linux、macOS等。它使用统一的构建系统(如Go Modules),可以轻松地跨平台编译和运行代码。 开源和社区支持:Go语言是开源的,具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之,Go语言是一种简单、高效、安全、并发的编程语言,特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言,并且需要处理大量的并发请求和数据,那么Go语言可能是一个不错的选择。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值