C++ BigInteger (beta version)

最新推荐文章于 2024-01-17 19:31:04 发布
原创 最新推荐文章于 2024-01-17 19:31:04 发布 · 8.8k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #vector #stream #string #iostream #algorithm

#include <deque>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

class DividedByZeroException {};

class BigInteger
{
    private:
        vector<char> digits; 
        bool sign;          //  true for positive, false for negitive
        void trim();        //  remove zeros in tail, but if the value is 0, keep only one:)
    public:
        BigInteger(int);    // construct with a int integer
        BigInteger(string&) ;
        BigInteger();
        BigInteger (const BigInteger&);
        BigInteger operator=(const BigInteger& op2);

        BigInteger      abs() const;
       BigInteger    pow(int a);

        //binary operators
        
        friend BigInteger operator+=(BigInteger&,const BigInteger&);
        friend BigInteger operator-=(BigInteger&,const BigInteger&);
        friend BigInteger operator*=(BigInteger&,const BigInteger&);
        friend BigInteger operator/=(BigInteger&,const BigInteger&) throw(DividedByZeroException);
        friend BigInteger operator%=(BigInteger&,const BigInteger&) throw(DividedByZeroException);       

        friend BigInteger operator+(const BigInteger&,const BigInteger&);
        friend BigInteger operator-(const BigInteger&,const BigInteger&);
        friend BigInteger operator*(const BigInteger&,const BigInteger&);
        friend BigInteger operator/(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
        friend BigInteger operator%(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
   

        //uniary operators
        friend BigInteger operator-(const BigInteger&);   //negative

        friend BigInteger operator++(BigInteger&);        //++v
        friend BigInteger operator++(BigInteger&,int);    //v++
        friend BigInteger operator--(BigInteger&);        //--v
        friend BigInteger operator--(BigInteger&,int);    //v--

        friend bool operator>(const BigInteger&,const BigInteger&);
        friend bool operator<(const BigInteger&,const BigInteger&);
        friend bool operator==(const BigInteger&,const BigInteger&);
        friend bool operator!=(const BigInteger&,const BigInteger&);
        friend bool operator>=(const BigInteger&,const BigInteger&);
        friend bool operator<=(const BigInteger&,const BigInteger&);

        friend ostream& operator<<(ostream&,const BigInteger&);    //print the BigInteger
        friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger

public:
        static const BigInteger ZERO;
        static const BigInteger ONE;
        static const BigInteger TEN;
};

// BigInteger.cpp

 const BigInteger BigInteger::ZERO=BigInteger(0);
 const BigInteger BigInteger::ONE =BigInteger(1);
 const BigInteger BigInteger::TEN =BigInteger(10);


BigInteger::BigInteger()
{
    sign=true; 
}


BigInteger::BigInteger(int val){// construct with a int integer
    if (val >= 0)
        sign = true;
    else{
        sign = false;
        val *= (-1);
    }
    do{
        digits.push_back( (char)(val%10) );
        val /= 10;
    } while ( val != 0 );
}


BigInteger::BigInteger(string& def){
    sign=true;
    for ( string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++){
        char ch = (*iter);
        if (iter == def.rend()-1){
            if ( ch == '+' )
                break;
            if(ch == '-' ){
                sign = false;
                break;
            }
        }
        digits.push_back( (char)((*iter) - '0' ) );
    }
    trim();
}

void BigInteger::trim(){
    vector<char>::reverse_iterator iter = digits.rbegin();
    while(!digits.empty() && (*iter) == 0){
        digits.pop_back();
        iter=digits.rbegin();
    }
    if( digits.size()==0 ){
        sign = true;
        digits.push_back(0);
    }
}


BigInteger::BigInteger(const BigInteger& op2){
    sign = op2.sign;
    digits=op2.digits;
}


BigInteger BigInteger::operator=(const BigInteger& op2){
            digits = op2.digits;
            sign = op2.sign;
            return (*this);
 }


BigInteger BigInteger::abs() const {
    if(sign)  return *this;
    else      return -(*this);
}

BigInteger BigInteger::pow(int a) 
{
    BigInteger res(1);
    for(int i=0; i<a; i++)
        res*=(*this);
    return res;
}

//binary operators
BigInteger operator+=(BigInteger& op1,const BigInteger& op2){
    if( op1.sign == op2.sign ){     //只处理相同的符号的情况，异号的情况给-处理
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();
        char to_add = 0;        //进位
        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
            (*iter1) = (*iter1) + (*iter2) + to_add;
            to_add = ((*iter1) > 9);    // 大于9进一位
            (*iter1) = (*iter1) % 10;
            iter1++; iter2++;
        }
        while ( iter1 != op1.digits.end() ){   // 
            (*iter1) = (*iter1) + to_add;
            to_add = ( (*iter1) > 9 );
            (*iter1) %= 10;
            iter1++;
        }
        while ( iter2 != op2.digits.end() ){
            char val = (*iter2) + to_add;
            to_add = (val > 9) ;
            val %= 10;
            op1.digits.push_back(val);
            iter2++;
        }
        if( to_add != 0 )
            op1.digits.push_back(to_add);
        return op1;
    }
    else{
        if (op1.sign)
            return op1 -= (-op2);
        else
            return op1= op2 - (-op1);
    }

}

BigInteger operator-=(BigInteger& op1,const BigInteger& op2){
    if( op1.sign == op2.sign ){     //只处理相同的符号的情况，异号的情况给+处理
        if(op1.sign) { 
            if(op1 < op2)  // 2 - 3
                return  op1=-(op2 - op1);
        } 
        else {
            if(-op1 > -op2)  // (-3)-(-2) = -(3 - 2)
                return op1=-((-op1)-(-op2));
            else             // (-2)-(-3) = 3 - 2 
                return op1= (-op2) - (-op1);
        }
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();

        char to_substract = 0;  //借位

        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
            (*iter1) = (*iter1) - (*iter2) - to_substract;
            to_substract = 0;
            if( (*iter1) < 0 ){
                to_substract=1;
                (*iter1) += 10;
            }
            iter1++;
            iter2++;
        }
        while ( iter1 != op1.digits.end() ){
            (*iter1) = (*iter1) - to_substract;
            to_substract = 0;
            if( (*iter1) < 0 ){
                to_substract=1;
                (*iter1) += 10;
            }
            else break;
            iter1++;
        }
        op1.trim();
        return op1;
    }
    else{
        if (op1 > BigInteger::ZERO)
            return op1 += (-op2);
        else
            return op1 = -(op2 + (-op1));
    }
}
BigInteger operator*=(BigInteger& op1,const BigInteger& op2){
    BigInteger result(0);
    if (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)
        result = BigInteger::ZERO;
    else{
        vector<char>::const_iterator iter2 = op2.digits.begin();
        while( iter2 != op2.digits.end() ){
            if(*iter2 != 0){
                deque<char> temp(op1.digits.begin() , op1.digits.end());
                char to_add = 0;
                deque<char>::iterator iter1 = temp.begin();
                while( iter1 != temp.end() ){
                    (*iter1) *= (*iter2);
                    (*iter1) += to_add;
                    to_add = (*iter1) / 10;
                    (*iter1) %= 10;
                    iter1++;
                }
                if( to_add != 0)
                    temp.push_back( to_add );
                int num_of_zeros = iter2 - op2.digits.begin();
                while(  num_of_zeros--)
                    temp.push_front(0);
                BigInteger temp2;
                temp2.digits.insert( temp2.digits.end() , temp.begin() , temp.end() );
                temp2.trim();
                result = result + temp2;
            }
            iter2++;
        }
        result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    }
    op1 = result;
    return op1;
}

BigInteger operator/=(BigInteger& op1 , const BigInteger& op2 ) throw(DividedByZeroException) {
    if( op2 == BigInteger::ZERO )
        throw DividedByZeroException();
    BigInteger t1 = op1.abs(), t2 = op2.abs();
    if ( t1 < t2 ){
        op1 = BigInteger::ZERO;
        return op1;
    }
    //现在 t1 > t2 > 0
    //只需将 t1/t2的结果交给result就可以了
    deque<char> temp;
    vector<char>::reverse_iterator iter = t1.digits.rbegin();

    BigInteger temp2(0);
    while( iter != t1.digits.rend() ){
        temp2 = temp2 * BigInteger::TEN + BigInteger( (int)(*iter) );
        char s = 0;
        while( temp2 >= t2 ){
            temp2 = temp2 - t2;
            s = s + 1;
        }
        temp.push_front( s );
        iter++;
    }
    op1.digits.clear();
    op1.digits.insert( op1.digits.end() , temp.begin() , temp.end() );
    op1.trim();
    op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    return op1;
}

BigInteger operator%=(BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
    return op1 -= ((op1 / op2)*op2);
}

BigInteger operator+(const BigInteger& op1,const BigInteger& op2){
    BigInteger temp(op1);
    temp += op2;
    return temp;
}
BigInteger operator-(const BigInteger& op1,const BigInteger& op2){
    BigInteger temp(op1);
    temp -= op2;
    return temp;
}

BigInteger operator*(const BigInteger& op1,const BigInteger& op2){
    BigInteger temp(op1);
    temp *= op2;
    return temp;

}

BigInteger operator/(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
    BigInteger temp(op1);
    temp /= op2;
    return temp;
}

BigInteger operator%(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
    BigInteger temp(op1);
    temp %= op2;
    return temp;
}

//uniary operators
BigInteger operator-(const BigInteger& op){   //negative
    BigInteger temp = BigInteger(op);
    temp.sign = !temp.sign;
    return temp;
}

BigInteger operator++(BigInteger& op){    //++v
    op += BigInteger::ONE;
    return op;
}

BigInteger operator++(BigInteger& op,int x){  //v++
    BigInteger temp(op);
    ++op;
    return temp;
}

BigInteger operator--(BigInteger& op){    //--v
    op -=  BigInteger::ONE;
    return op;
}

BigInteger operator--(BigInteger& op,int x){  //v--
    BigInteger temp(op);
    --op;
    return temp;
}

bool operator<(const BigInteger& op1,const BigInteger& op2){
    if( op1.sign != op2.sign )
        return !op1.sign;
    else{
        if(op1.digits.size() != op2.digits.size())
            return (op1.sign && op1.digits.size()<op2.digits.size())
                       || (!op1.sign && op1.digits.size()>op2.digits.size());
        vector<char>::const_reverse_iterator iter1,iter2;
        iter1 = op1.digits.rbegin();iter2 = op2.digits.rbegin();
        while( iter1 != op1.digits.rend() ){
            if(  op1.sign &&  *iter1 < *iter2 ) return true;
            if(  op1.sign &&  *iter1 > *iter2 ) return false;
            if( !op1.sign &&  *iter1 > *iter2 ) return true;
            if( !op1.sign &&  *iter1 < *iter2 ) return false;
            iter1++;
            iter2++;
        }
        return false;
    }
}
bool operator==(const BigInteger& op1,const BigInteger& op2){
    if( op1.sign != op2.sign  || op1.digits.size() != op2.digits.size() )
        return false;
    vector<char>::const_iterator iter1,iter2;
    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
    while( iter1!= op1.digits.end() ){
        if( *iter1 != *iter2 )  return false;
        iter1++;
        iter2++;
    }
    return true;
}

bool operator!=(const BigInteger& op1,const BigInteger& op2){
    return !(op1==op2);
}

bool operator>=(const BigInteger& op1,const BigInteger& op2){
    return (op1>op2) || (op1==op2);
}

bool operator<=(const BigInteger& op1,const BigInteger& op2){
    return (op1<op2) || (op1==op2);
}

bool operator>(const BigInteger& op1,const BigInteger& op2){
    return !(op1<=op2);
}

ostream& operator<<(ostream& stream,const BigInteger& val){    //print the BigInteger
    if (!val.sign)
        stream << "-";
    for ( vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++)
        stream << (char)((*iter) + '0');
    return stream;
}

istream& operator>>(istream& stream, BigInteger& val){    //Input the BigInteger
    string str;
    stream >> str;
    val=BigInteger(str);
    return stream;
}

////////////////////////////////////////////////////////////

int main()
{
    int n;
    cin>>n;
    for(int i=0; i<n; i++) {
        BigInteger A;
        BigInteger B;
        BigInteger C=888;
        cin>>A>>B;
        cout<<"A-B:"<<A-B<<endl;
        cout<<"A+B:"<<A+B<<endl;
        cout<<"A*B:"<<A*B<<endl;
        cout<<"A/B:"<<A/B<<endl;
        cout<<"A%B:"<<A%B<<endl;
        cout<<"A.pow(5)"<<A.pow(5)<<endl;
        A++;
        cout<<"A++:"<<A<<endl;
        A--;
        cout<<"A--:"<<A<<endl;
        cout<<"++B:"<<++B<<endl;
        cout<<"--B:"<<--B<<endl;
        cout<<"C:"<<C<<endl;
    }
    return 0;
}
[中等] 比较完整的BigInteger高精度整数类（C++实现）
zypang1的博客
08-28 2612
具体代码： 其中BigInteger/BigInteger用得应该会少一些，下面代码中的这个函数需要进一步的测试，不过其思想并不难。 另外对于求模运算，可以容易地通过除法运算的代码获得。 #include #include #include using namespace std; struct BigInteger { vector s; static const
C++ 大整数类（无符号BigInteger类和带符号SignedBigInteger类）实现
Gxysbra的博客
10-17 4284
C++ BigInteger类实现，存储任意大小的非负整数 参考 算法竞赛入门经典第二版 5.3 节——大整数类 代码（先放代码，后续追加注释与可以为负数的实现） #include <string> #include <vector> #include <algorithm> #include <iostream> using namespace std; /** * 存储任意大小的非负整数 */ class BigInteger { fr
BigInteger:C ++实现BigInteger
03-28
大整数 C ++实现BigInteger
c++ 大整数库 big integer
10-15
c++ 大整数库 big integer 来自https://mattmccutchen.net/bigint/
C++手搓大整数类
笔记
01-17 1276
char是8位的，short是16位的，int是32位的，最大的long long是64位的，也就是说基本的数据类型无法表示超过2的64次方-1的数。实现大整数有两种方法，一种是将大数当成字符来处理，手动计算加减乘除，另一种则是将大数分成多个小部分用基本类型存储处理。如今又到了找工作的时候了，面试手撕题少不了，听说这个手搓大整数也有过面试题，这里先搓一手，免得以后执手相看泪眼。我们这里实现第二种方法的。
RSA.rar_BigInteger_RSA BigInteger_RSA java biginteger_RSA 类 java
09-20
在Java中，我们可以使用`java.math.BigInteger`类来处理大整数，这在实现RSA算法时非常关键，因为加密过程中涉及的数字通常超过了普通整型变量的范围。以下是关于`BigInteger`类以及如何在Java中实现RSA加解密的详细...
C++大整数类bigInteger及几个重载运算符
Andy__P的博客
05-16 1785
大整数类，重载运算符"<<",">>","!=","+=","+","*",uva424,uva485,uva495,uva324设计大整数类以及几个运算符重载//">>"重载//"<<"重载//"!="重载//"+="重载//"+"重载//"*"重载//uva424主函数//uva495主函数//uva485主函数//uva324主函数 设计大整数...
BigInteger.js
11-01
JavaScript支持大整数,页面需要进入BigInteger.js。才能使用
[C++]大数Integer类
02-14
[C++]大数Integer类。支持大数加减乘除。支持如下操作：>, >=, <, <=, ==, !=, +, +=, -, -=, *, =, /, /=,<<(输出)；支持利用基本整数类型(int,unsigned,long long,……)和字符串(char和std::string)构造类型；支持取绝对值abs()操作！
[C++][New]大数Integer类
02-15
由于使用模板，所以只有一个Integer.h头文件 支持如下操作：>, >=, <, <=, ==, !=, +, +=, -, -=, *, =, /, /=,<<(输出)；支持利用基本整数类型(int,unsigned,long long,……)和字符串(char和std::string)构造类型
[模板] C++ BigInteger 类
LucienShui
08-07 2364
永久地址 http://www.lucien.ink/archives/313/ 不多比比，直接上模板 #include&lt;bits/stdc++.h&gt; //大整数 struct BigInteger { static const int BASE = 100000000;//和WIDTH保持一致 static const int WIDTH = 8;//八位...
BigInteger 大整数类（C++）
dragonylee的博客
08-10 1312
有时候需要用到大整数，这里放一个自己写的大整数结构体（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
aoquandao8917的博客
09-12 865
网上C++版Biginteger参差不齐，一下子没有找到一个令人满意Biginteger，最近用c++改写了一下C#版 BigInteger，可以用于RSA大素数的生成，分享给大家。也请大家批评指正改的不好的地方。 其中有几个类型未在CPP中： typedef unsigned char Byte; #define null 0 typedef unsigned int Uint...
C++ 实现BigInteger 类
热门推荐
Dmaxiya
07-01 1万+
本文提供可复用 C++ BigInteger 类的声明与实现，读者可直接复制使用或从 Github 上获取代码，笔者希望能提供“像使用基本数据类型一样方便”的高精度整数类
用C++实现Bigintger类
m0_51303687的博客
11-04 611
前几天受到Java中Biginteger类的启发，自己用C++ 写了一个大整数类，目前功能还很不完善，只支持加、减、乘、比较大小而且不支持负数。代码如下： /*注意点 *1.数字存储方式：data[0]为最低位，往后依次升高 *2.注意0的特殊处理 */ #ifndef BIGINT_H #define BIGINT_H #include <cstring> #include <string> #include <algorithm> //std::reverse
C++大数模板 BigInteger
智障
08-11 8913
网上搜集的一份写的灰常漂亮的大数模板。Mark之~~~~ 看不懂的自行补脑了 +_+ #include #include #include using namespace std; struct BigInteger{ int A[25]; enum{MOD = 10000}; BigInteger(){memset(A, 0, sizeof(A));
C++ BigInteger模板
Macan - 生活点滴
01-06 755
1 #include 2 #include 3 #include string> 4 #include 5 #include 6 #include 7 using namespace std; 8 9 #define MAXN 9999 10 #define MAXSIZE 10 11 #define DLEN 4 12 co
大数模板
月殇
08-22 185
#include&lt;bits/stdc++.h&gt; using namespace std; //大整数 struct BigInteger { static const int BASE=100000000;//和WIDTH保持一致 static const int WIDTH=8;//八位一存储,如修改记得修改输出中的%08d bool sign;//符号, ...
c++大整数类biginteger怎么使用
最新发布
02-28
### 使用 C++ 中的大整数类 `BigInteger` 在标准 C++ 库中并没有直接提供名为 `BigInteger` 的类来处理任意精度的整数运算。然而，可以借助第三方库如 GMP（GNU Multiple Precision Arithmetic Library），该库提供了强大的多精度算术功能。 安装并配置好 GMP 后，在程序里可以通过包含头文件 `<gmpxx.h>` 来访问其提供的类 `mpz_class`，这个类能够很好地替代其他语言中的 `BigInteger` 类型[^3]。 下面给出一段简单的例子展示如何定义以及操作大整数值： ```cpp #include <iostream> #include <gmpxx.h> // 包含GMP扩展C++接口 int main() { mpz_class bigInt1("98765432109876543210"); // 初始化一个很大的正整数 mpz_class bigInt2("-98765432109876543210"); // 负数也可以这样初始化 std::cout << "BigInt1: " << bigInt1.get_str() << "\n"; // 输出bigInt1 std::cout << "BigInt2: " << bigInt2.get_str(16) << "\n"; // 将bigInt2转换成十六进制字符串输出 mpz_class resultAdd = bigInt1 + abs(bigInt2); // 加法运算 std::cout << "Sum of BigInts: " << resultAdd.get_str() << "\n"; return 0; } ``` 此代码片段展示了创建两个不同符号的大整数对象，并执行加法运算的过程。注意这里使用了绝对值函数 `abs()` 来确保相加时不考虑负号的影响[^3]。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值