c++ 大整数类

最新推荐文章于 2024-01-18 12:15:17 发布
最新推荐文章于 2024-01-18 12:15:17 发布
阅读量1k 收藏
点赞数
分类专栏： 天下君的算法学习 文章标签： c++ 大整数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OSFPU/article/details/51166440
版权

具体使用见main函数

#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <sstream>
using namespace::std;

class BigInteger {
    friend BigInteger big_abs(const BigInteger &a);
    friend ostream& operator << (ostream& out, const BigInteger &a);
    friend istream& operator >> (istream& out, BigInteger &a);
    friend bool operator > (const BigInteger &a, const BigInteger &b);
    friend bool operator < (const BigInteger &a, const BigInteger &b);
    friend bool operator >= (const BigInteger &a, const BigInteger &b);
    friend bool operator <= (const BigInteger &a, const BigInteger &b);
    friend bool operator == (const BigInteger &a, const BigInteger &b);
    friend BigInteger operator + (const BigInteger &a, const BigInteger &b);
    friend BigInteger operator - (const BigInteger &a, const BigInteger &b);
    friend BigInteger operator * (const BigInteger &a, const BigInteger &b);
    friend BigInteger operator / (const BigInteger &a, const BigInteger &b);
    friend BigInteger operator % (const BigInteger &a, const BigInteger &b);
    friend BigInteger operator ^ (const BigInteger &a, const BigInteger &b);
private:
    string integer;
    bool positive;
    static string big_add(const string &a, const string &b);
    static string big_sub(const string &a, const string &b);
    static string big_mul(const string &a, const string &b);
    static string big_div(const string &a, const string &b,string &remainder_ret);
    static int big_cmp(const string &a, const string &b);
public:
    BigInteger(string _integer = "0", bool _positive = true) {
        setInteger(_integer, _positive);
    }
    BigInteger(long long _integer) {
        setInteger(_integer);
    }
    BigInteger(const BigInteger &_integer) {
        setInteger(_integer.integer, _integer.positive);
    }
    void setInteger(string _integer = "0", bool _positive = true);
    void setInteger(long long _integer);

};

BigInteger big_abs(const BigInteger &a) {
    BigInteger res(a.integer, true);
    return res;
}

int BigInteger::big_cmp(const string &a, const string &b) {
    if (a.size() > b.size()) {
        return 1;
    } else if (a.size() < b.size()) {
        return -1;
    } else {
        for (int i = 0; i < a.size(); i++) {
            if(a[i] > b[i]) {
                return 1;
            } else if(a[i] < b[i]) {
                return -1;
            }
        }
        return 0;
    }

}

string BigInteger::big_add(const string &a, const string &b) {
    string res(a.size() > b.size() ? a.size() + 1 : b.size() + 1, '0');
    int ai = (int)a.size() - 1;
    int bi = (int)b.size() - 1;
    int i = (int)res.size() - 1;
    int acc = 0;
    while (ai >= 0 && bi >= 0) {
        int tmp = a[ai--] - '0' + b[bi--] - '0' + acc;
        res[i--] = tmp % 10 + '0';
        acc = tmp / 10;
    }
    while (ai >= 0) {
        int tmp = a[ai--] - '0' + acc;
        res[i--] = tmp % 10 + '0';
        acc = tmp / 10;
    }
    while (bi >= 0) {
        int tmp = b[bi--] - '0' + acc;
        res[i--] = tmp % 10 + '0';
        acc = tmp / 10;
    }
    if (acc != 0) {
        res[0] += acc;
    }
    return res[0] == '0' ? res.substr(1) : res;
}

string BigInteger::big_sub(const string &a, const string &b) {
    string res(a.size(), '0');
    int ai = (int)a.size() - 1;
    int bi = (int)b.size() - 1;
    int i = (int)res.size() - 1;
    int bor = 0;
    while (ai >= 0 && bi >= 0) {
        int ta = a[ai--] - '0' - bor;
        int tb = b[bi--] - '0';
        if (ta < tb) {
            bor = 1;
            ta += 10;
        } else {
            bor = 0;
        }
        res[i--] = ta - tb + '0';
    }
    while (ai >= 0) {
        int ta = a[ai--] - '0' - bor;
        int tb = 0;
        if (ta < tb) {
            bor = 1;
            ta += 10;
        } else {
            bor = 0;
        }
        res[i--] = ta - tb + '0';
    }
    for (int i = 0; i < res.size(); i++) {
        if (res[i] != '0') {
            return res.substr(i);
        }
    }
    return "0";
}

string BigInteger::big_mul(const string &a, const string &b) {
    if (a == "0" || b == "0") return string("0");
    int m = (int)a.length();
    int n = (int)b.length();
    vector<int> pos(m + n, 0);
    for (int i = m - 1; i >= 0; i--) {
        for(int j = n - 1; j >= 0; j--) {
            int p1 = i + j, p2 = i + j + 1;
            int mul = (a[i] - '0') * (b[j] - '0');
            int sum = mul + pos[p2];
            pos[p1] += sum / 10;
            pos[p2] = sum % 10;
        }
    }
    string res;
    for(int p : pos) {
        if (!(p == 0 && res.empty())) {
            res.append(1, p + '0');
        }
    }
    return res;
}

string BigInteger::big_div(const string &a, const string &b, string &remainder_ret) {
    string res(a.size(), '0');
    string remainder = "";
    for (int i = 0; i < res.size(); ) {
        if (remainder == "0" && a[i] == '0') {
            i++;
            continue;
        }
        int len = 1;
        while (i + len <= a.size() && BigInteger::big_cmp(remainder + a.substr(i, len), b) < 0) {
            len++;
        }
        string cur = remainder + a.substr(i, len);
        if (i + len > a.size()) {
            remainder = cur;
            break;
        }
        for (int j = 9; j > 0; j--) {
            string tmp = "0";
            tmp[0] += j;
            if (big_cmp(big_mul(tmp, b), cur) <= 0) {
                res[i + len - 1] = tmp[0];
                remainder = big_sub(cur, big_mul(tmp, b));
                if (remainder == "0") {
                    remainder = "";
                }
                break;
            }
        }
        i += len;
    }
    if (remainder == "") {
        remainder = "0";
    }
    remainder_ret = remainder;
    for (int i = 0; i < res.size(); i++) {
        if (res[i] != '0') {
            return res.substr(i);
        }
    }
    return "0";
}

bool operator > (const BigInteger &a, const BigInteger &b) {
    if (a.positive && !b.positive) {
        return true;
    } else if (!a.positive && b.positive) {
        return false;
    } else if (a.positive && b.positive) {
        if (BigInteger::big_cmp(a.integer, b.integer) > 0) {
            return true;
        } else {
            return false;
        }
    } else {
        if (BigInteger::big_cmp(a.integer, b.integer) < 0) {
            return true;
        } else {
            return false;
        }
    }
}

bool operator < (const BigInteger &a, const BigInteger &b) {
    if (a.positive && !b.positive) {
        return false;
    } else if (!a.positive && b.positive) {
        return true;
    } else if (a.positive && b.positive) {
        if (BigInteger::big_cmp(a.integer, b.integer) < 0) {
            return true;
        } else {
            return false;
        }
    } else {
        if (BigInteger::big_cmp(a.integer, b.integer) > 0) {
            return true;
        } else {
            return false;
        }
    }
}

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

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

bool operator == (const BigInteger &a, const BigInteger &b) {
    if (a.positive == b.positive && a.integer == b.integer) {
        return true;
    } else {
        return false;
    }
}

ostream& operator << (ostream &out, const BigInteger &a) {
    if (!a.positive) {
        out << "-";
    }
    out << a.integer;
    return out;
}

istream& operator >> (istream& in, BigInteger& a) {
    string str;
    in >> str;
    a.setInteger(str);
    return in;
}

BigInteger operator + (const BigInteger &a, const BigInteger &b) {
    BigInteger res;
    if (a.positive && b.positive) {
        res.setInteger(BigInteger::big_add(a.integer, b.integer), true);
    } else if (!a.positive && !b.positive) {
        res.setInteger(BigInteger::big_add(a.integer, b.integer), false);
    } else {
        if (big_abs(a) == big_abs(b)) {
            res.setInteger(0);
        } else if (big_abs(a) > big_abs(b)) {
            res.setInteger(BigInteger::big_sub(a.integer, b.integer), a.positive);
        } else {
            res.setInteger(BigInteger::big_sub(b.integer, a.integer), b.positive);
        }
    }
    return res;
}

BigInteger operator - (const BigInteger &a, const BigInteger &b) {
    BigInteger b_neg(b.integer, !b.positive);
    return a + b_neg;
}

BigInteger operator * (const BigInteger &a, const BigInteger &b) {
    if (a.integer == "0" || b.integer == "0") {
        return BigInteger(0);
    }
    return BigInteger(BigInteger::big_mul(a.integer, b.integer)
                      , a.positive == b.positive ? true : false);
}

BigInteger operator / (const BigInteger &a, const BigInteger &b) {
    if (big_abs(a) < big_abs(b)) {
        return BigInteger(0);
    }
    string remainder;
    return BigInteger(BigInteger::big_div(a.integer, b.integer, remainder)
                      , a.positive == b.positive ? true : false);
}

BigInteger operator % (const BigInteger &a, const BigInteger &b) {
    if (big_abs(a) < big_abs(b)) {
        return BigInteger(a);
    }
    string remainder;
    BigInteger::big_div(a.integer, b.integer, remainder);
    return BigInteger(remainder, a.positive);
}

BigInteger operator ^ (const BigInteger &a, const BigInteger &b) {
    if (a.integer == "1" && b == BigInteger(-1)) {
        return BigInteger(a);
    }
    if (a.integer == "0" || !b.positive) {
        return BigInteger(0);
    }
    if (b.integer == "0") {
        return BigInteger(1);
    }
    if (a.integer == "1") {
        return b % BigInteger(2) == BigInteger(0) ? BigInteger(1) : BigInteger("1", a.positive);
    }
    if (b == BigInteger(1)) {
        return BigInteger(a);
    }
    return b % BigInteger(2) == BigInteger(0) ? (a * a) ^ (b / BigInteger(2)) : a * ((a * a) ^ (b / BigInteger(2)));
}


void BigInteger::setInteger(string _integer, bool _positive) {
    if (_integer == "0") {
        this->integer = _integer;
        this->positive = true;
        return;
    }
    if (_integer[0] == '-') {
        this->positive = false;
        this->integer = _integer.substr(1);
    } else {
        this->integer = _integer;
        this->positive = _positive;
    }
}

void BigInteger::setInteger(long long _integer) {
    if (_integer >= 0) {
        this->positive = true;
    } else {
        this->positive = false;
        _integer = -_integer;
    }
    stringstream ss;
    ss << _integer;
    this->integer = ss.str();
}



int main() {
    /*
     * 构造函数分为以下2种, 并且可以使用setInteger成员函数重新设置大整数, 可混合使用
        (1) 使用string
            string a = "-101";
            BigInteger bi_a(a);
            bi_a.setInteger("1024");
            string b = "7777"
            BigInteger bi_b(b);
        (2) 使用整数
            BigInteger bi_a(-101);
            BigInteger bi_b(65533);
            bi_b.setInteger(234);

     * 大整数运算包含加减乘除，求余，求次方，注意:由于优先级的问题，求次方的时候加括号，例如(a ^ b)
     * 
     * 支持 > < >= <= == 的比较
     *
     * 可以使用big_abs()函数求绝对值
     */
    string a = "-24";
    int b = 123;
    BigInteger ba(a);
    BigInteger bb(b);
    cout << "a = " << ba << ", " << "b = " << bb << endl;
    cout << "a + b = " << ba + bb << endl;
    cout << "a - b = " << ba - bb << endl;
    cout << "a * b = " << ba * bb << endl;
    cout << "a / b = " << ba / bb << endl;
    cout << "b / a = " << bb / ba << endl;
    cout << "b % abs(a) = " << bb % ba << endl;
    ba.setInteger(-2);
    bb.setInteger("11");
    cout << "a = " << ba << ", " << "b = " << bb << endl;
    cout << "a ^ b = " << (ba ^ bb) << endl; //求次方需加括号，否则会报错
    cout << "b ^ abs(a) = " << (bb ^ big_abs(ba)) << endl; //求次方需加括号，否则会报错
    cout << "b ^ 3 = " << (bb ^ BigInteger(3)) << endl; //求次方需加括号，否则会报错
    ba.setInteger("1023142141414141");
    bb.setInteger("1241414");
    cout << "a = " << ba << ", " << "b = " << bb << endl;
    cout << "a + b = " << ba + bb << endl;
    cout << "a - b = " << ba - bb << endl;
    cout << "a * b = " << ba * bb << endl;
    cout << "a / b = " << ba / bb << endl;
    cout << "b / a = " << bb / ba << endl;
    cout << "a % b = " << ba % bb << endl;
    return 0;
}
OSFPU
关注
专栏目录
C++大整数类bigInteger及几个重载运算符
Andy__P的博客
05-16 1699
大整数类，重载运算符"<<",">>","!=","+=","+","*",uva424,uva485,uva495,uva324设计大整数类以及几个运算符重载//">>"重载//"<<"重载//"!="重载//"+="重载//"+"重载//"*"重载//uva424主函数//uva495主函数//uva485主函数//uva324主函数 设计大整数...
C++大整数类
04-13
大整数，可是输入任意位数的整数，示例出100内质数之和
简单介绍C++大整数类
m0_65305142的博客
07-02 1989
比如字符串是字符“1234”的组合，通过上述步骤var中得到的是真正int型1234。众所周知有符号的int型最大数据为2147483647（一共10位），所以取BASE为8位，且代码保证进入vector的数据都小于BASE，所以一定不会超限。，作用是将string类型的第一个元素值返回，达到的是一个将C++风格字符串转换为C风格的字符数组的效果。，表示取出原字符串中下标从start开始的长度为n的子字符串，返回值同样是string。同理，取WIDTH为8保证了每一次只录入长度≤8的数据，小于int。
C++类实现大整数
MuQYun的博客
12-02 1357
在计算机科学和工程中，整数类型有一个上限，称为其最大值或最大表示值，这限制了数字的大小范围。在一些应用中，需要处理比这个上限更大的整数，这时就需要使用大整数类。 大整数类允许处理比计算机所提供的整数类型更大的整数，通常是以字符串形式存储，可以进行算术运算、比较和转换等操作。这在密码学、数值计算、物理仿真、金融等领域中非常有用。 比如在密码学中，RSA加密算法就需要对非常大的整数进行加密和解密。在数值计算中，需要进行高精度计算，避免舍入误差，保证计算结果的准确性。在物理仿真中，需要模拟非常大或非常小的量。
大整数类c++实现
01-01
这是我的处女发，呵呵。 言归正传，这是我们老师提供给我们让我们编写高精度有理数用的，这个类包很小，功能也只是一些基本运算。我自己也曾经试着写一个大整数类，但和大多数初学者一样卡在了除法上。在这个类包中，除法用的是折半试商法，但我个人认为效率很低。 还有许多大整数类包，可以在网上下到，但我觉得这个对初学者很好。特别是对运算符重载的学习。 另外，我从一本数值算法书中也找到了一个高精度运算的实现。有点难，本人数值分析学得糟，正在着磨中。但我学习数值分析的过程中认识到的是：数值解再精确也是一个逼近值。我不理解怎么会用数值算法解决高精度运算呢。 我把书向大家推荐一下，希望大家一起探讨。《Numerical Recipes in c++》作者：William H.press, Saul A.Teukolsky等，电子工业出版社出版的翻译版《c++数值算法》第668页。
C++ 大整数类（支持上亿个位的整数 '+'、'-'、'*'、'/'、'%'、'^' 计算实现）
04-18
C++ 大整数类（支持上亿个位的整数 '+'、'-'、'*'、'/'、'%'、'^' 计算实现），基本数据类型 long long int 类型也只能保存最大20位数，设计此类来保存上亿位的数。此类运用了大量C++的基础语法，无参构造、数值构造...
C++　超大整数类　及RSA加密
02-25
本文将深入探讨C++中的大整数类实现以及RSA加密解密技术。 大整数类（BigInteger）是为了能够存储和操作超过普通整型变量（如int、long等）范围的数值而设计的。在C++中，标准库并不直接提供大整数的支持，因此我们...
C++大整数类/高精度类/LargeNum（上万位数秒算）
最新发布
lixuean0408的博客
01-18 2248
项目名称：C++大整数类开发环境：devc++优化级别：自动C++标准：ISOC++11在我们实际的编程当中，C++自带的整数类型只占用固定的内存，所以变量的最大值和最小值也就是固定的，非常的不妙。即使是最大的unsigned long long，也只能存储2^64-1的数，对于某些算法（例如RSA非对称加密算法），它们需要极大的数据存储量。因此，我就制作了一个大整数类。
C++有符号大整数类型bigint
03-23
自定义的C++有符号大整数类型bigint
大整数类C++实现（绝对可用）
06-30
大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）
大数类c++大数类
06-05
c++大数类，重载了全部运算符，很详细
大整数加法 c++
12-08
能够实现超出int类型表示的大整数的加法运算
C++大整数运算
10-28
用C++写的大整数运算，包含加减乘除以及求余
HDU 1134 大数取模 使用大数模板
vsooda的专栏
01-25 4647
#include #include #include #include using namespace std; char str[1010]; int modd; #define MAXN 9999 #define MAXSIZE 10 #define DLEN 4 class BigNum { private: int a[1010]; //可以控制大数的位数 i
C++大整数类（支持多种进制）
[PE]经典八炮的博客
05-14 6524
一、简介 项目名称：C++大整数类 开发环境：Visual Studio 2022 C++标准：C++20 C++中是有整数类型的，最常用的就是int型。但是，C++自带的整数类型是有大小范围的，可能会溢出，产生很多令人头疼的错误。 示例： #include<iostream> //#include"CBigInt.h" using namespace std; int main() { int t = 1; for (int i = 0; i < 100; i++) { t *
C++实现大整数运算类
"C++实现的大数类，用于处理大整数运算，使用字符串存储大整数，并且只重载了大于号操作符。" 在C++编程中，处理大整数运算通常需要自定义数据结构和算法，因为标准库中的整型类型如int、long等在处理非常大的数字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值