C++大数类

最新推荐文章于 2024-05-08 21:31:31 发布
最新推荐文章于 2024-05-08 21:31:31 发布
阅读量770 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenjun15/article/details/122151436
版权 
BigInteger.h:

#ifndef _BIGINTEGER_H_
#define _BIGINTEGER_H_

#include <iostream>
#include <limits>
#include <string>

class BigInteger {
  public:
    BigInteger();

    BigInteger(long long);

    /**
     * @brief 以8/10/16进制字符串为参数构造BigInteger
     * ex: 070, 128, 0x1f
     */
    BigInteger(const std::string &);

    BigInteger(const BigInteger &);

    BigInteger &operator+();

    BigInteger operator-() const;

    BigInteger &operator++();

    BigInteger operator++(int);

    BigInteger &operator--();

    BigInteger operator--(int);

    BigInteger &operator=(const BigInteger &);

    BigInteger &operator+=(const BigInteger &);

    friend BigInteger operator+(const BigInteger &, const BigInteger &);

    BigInteger &operator-=(const BigInteger &);

    friend BigInteger operator-(const BigInteger &, const BigInteger &);

    BigInteger &operator*=(const BigInteger &);

    friend BigInteger operator*(const BigInteger &, const BigInteger &);

    BigInteger &operator/=(const BigInteger &);

    friend BigInteger operator/(const BigInteger &, const BigInteger &);

    BigInteger &operator%=(const BigInteger &);

    friend BigInteger operator%(const BigInteger &, const BigInteger &);

    friend std::istream &operator>>(std::istream &, const BigInteger &);

    friend std::ostream &operator<<(std::ostream &, 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 bool operator<=(const BigInteger &, const BigInteger &);

  private:
    bool isNegtive;
    std::string mData;
};

#endif
BigInteger.cpp

#include "BigInteger.h"
#include <stdexcept>
#include <vector>
#include <cstring>
#include <deque>
#include <cassert>
using namespace std;

static bool convertBase(int base0, int base1, const char *from, std::string &to);

static int dexCompare(const std::string &a, const std::string &b);

static string Add(const std::string &a, const std::string &b);

static string Minus(const std::string &a, const std::string &b);

static string Multiply(const std::string &a, const std::string &b);

static string Divide(const std::string &a, const std::string &b);

BigInteger::BigInteger() : isNegtive(false), mData("0")
{
}

BigInteger::BigInteger(long long num) : isNegtive(num < 0), mData(to_string(abs(num)))
{
}

BigInteger::BigInteger(const std::string &sNum)
{
    size_t b = sNum.find_first_not_of(' ');
    if (b == string::npos)
        goto error;
    if (sNum[b] == '-') {
        isNegtive = true;
        b = sNum.find_first_not_of(' ', b + 1);
        if (b == string::npos)
            goto error;
    } else if (isdigit(sNum[b]))
        isNegtive = false;
    else
        goto error;

    int base;
    if (sNum[b] == '0') {
        if (b + 1 == sNum.size()) {
            isNegtive = false;
            mData = "0";
            return;
        }
        if (sNum[b + 1] == 'x' || sNum[b + 1] == 'X') {
            base = 16;
            b += 2;
        } else {
            base = 8;
            ++b;
        }
        if (b == sNum.size())
            goto error;
    } else
        base = 10;

    if (convertBase(base, 10, sNum.c_str() + b, mData))
        return;

    error:
    throw invalid_argument(sNum);
}

BigInteger::BigInteger(const BigInteger &rhs) : isNegtive(rhs.isNegtive), mData(rhs.mData)
{
}

BigInteger &BigInteger::operator=(const BigInteger &rhs)
{
    if (this != &rhs) {
        isNegtive = rhs.isNegtive;
        mData = rhs.mData;
    }
    return *this;
}

BigInteger &BigInteger::operator+()
{
    return *this;
}

BigInteger BigInteger::operator-() const
{
    BigInteger bi(*this);
    if (mData != "0")
        bi.isNegtive = !isNegtive;
    return bi;
}

BigInteger &BigInteger::operator++()
{
    *this += 1;
    return *this;
}

BigInteger BigInteger::operator++(int)
{
    BigInteger bi(*this);
    bi += 1;
    return bi;
}

BigInteger &BigInteger::operator--()
{
    *this -= 1;
    return *this;
}

BigInteger BigInteger::operator--(int)
{
    BigInteger bi(*this);
    bi -= 1;
    return bi;
}

bool operator==(const BigInteger &a, const BigInteger &b)
{
    return a.isNegtive == b.isNegtive && a.mData == b.mData;
}

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

bool operator>(const BigInteger &a, const BigInteger &b)
{
    if (a.isNegtive != b.isNegtive)
        return !a.isNegtive;
    return a.isNegtive ? dexCompare(a.mData, b.mData) < 0 : dexCompare(a.mData, b.mData) > 0;
}

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

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

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

BigInteger &BigInteger::operator+=(const BigInteger &rhs)
{
    if (isNegtive) {
        if (rhs.isNegtive) {
            mData = Add(mData, rhs.mData);
        } else {
            int cmp = dexCompare(mData, rhs.mData);
            if (cmp == 0) {
                isNegtive = false;
                mData = "0";
            } else if (cmp > 0) {
                mData = Minus(mData, rhs.mData);
            } else {
                isNegtive = false;
                mData = Minus(rhs.mData, mData);
            }
        }
    } else {
        if (!rhs.isNegtive)
            mData = Add(mData, rhs.mData);
        else {
            int cmp = dexCompare(mData, rhs.mData);
            if (cmp == 0) {
                isNegtive = false;
                mData = "0";
            } else if (cmp > 0) {
                mData = Minus(mData, rhs.mData);
            } else {
                isNegtive = true;
                mData = Minus(rhs.mData, mData);
            }
        }
    }
    return *this;
}

BigInteger operator+(const BigInteger &a, const BigInteger &b)
{
    BigInteger c(a);
    return c += b;
}

BigInteger &BigInteger::operator-=(const BigInteger &rhs)
{
    *this += -rhs;
    return *this;
}

BigInteger operator-(const BigInteger &a, const BigInteger &b)
{
    BigInteger c(a);
    return c -= b;
}

BigInteger &BigInteger::operator*=(const BigInteger &rhs)
{
    if (mData != "0") {
        if (rhs.mData == "0") {
            isNegtive = false;
            mData = "0";
        } else {
            isNegtive = (isNegtive && !rhs.isNegtive) || (!isNegtive && rhs.isNegtive);
            mData = Multiply(mData, rhs.mData);
        }
    }
    return *this;
}

BigInteger operator*(const BigInteger &a, const BigInteger &b)
{
    BigInteger c(a);
    return c *= b;
}

BigInteger &BigInteger::operator/=(const BigInteger &rhs)
{
    if (rhs.mData == "0")
        throw invalid_argument("divided by zero");
    if (mData != "0") {
        mData = Divide(mData, rhs.mData);
        if (mData == "0")
            isNegtive = false;
        else
            isNegtive = (isNegtive && !rhs.isNegtive) || (!isNegtive && rhs.isNegtive);
    }
    return *this;
}

BigInteger operator/(const BigInteger &a, const BigInteger &b)
{
    BigInteger c(a);
    return c /= b;
}

BigInteger &BigInteger::operator%=(const BigInteger &rhs)
{
    BigInteger r = *this / rhs;
    *this -= r * rhs;
    return *this;
}

BigInteger operator%(const BigInteger &a, const BigInteger &b)
{
    BigInteger c(a);
    return c %= b;
}

//BigInteger BigInteger::operator%(const BigInteger &rhs) const
//{
//    BigInteger bi(*this);
//    bi %= rhs;
//    return bi;
//}

std::istream &operator>>(std::istream &is, BigInteger &bi)
{
    string num;
    is >> num;
    try {
        BigInteger x(num);
        bi = x;
    } catch (invalid_argument &ia) {
        cerr << ia.what() << endl;
    }
    return is;
}

std::ostream &operator<<(std::ostream &os, const BigInteger &bi)
{
    if (bi.isNegtive)
        os << '-';
    return os << bi.mData;
}

static inline int char2int(char c)
{
    if (isdigit(c))
        return c - '0';
    if (c >= 'A' && c <= 'F')
        return c - 'A' + 10;
    if (c >= 'a' && c <= 'f')
        return c - 'a';
    return std::numeric_limits<int>::max();
}

static bool convertBase(int base0, int base1, const char *from, std::string &to)
{
    if (base0 == base1) {
        to.assign(from);
        return true;
    }
    int len = strlen(from);
    vector<int> a(len);
    deque<char> dq;
    for (int i = 0; i < len; ++i)
        if ((a[len - i - 1] = char2int(from[i])) >= base0)
            return false;
    while (len) {
        for (int i = len - 1; i; --i) {
            a[i - 1] += a[i] % base1 * base0;
            a[i] /= base1;
        }
        dq.push_front(a[0] % base1 + '0');
        a[0] /= base1;
        while (len && a[len - 1] == 0)
            --len;
    }
    to.assign(dq.cbegin(), dq.cend());
    return true;
}

/**
 * @brief 比较两个十进制大数的大小
 *
 * @param a
 * @param b
 * @return int
 */
static int dexCompare(const std::string &a, const std::string &b)
{
    if (a.size() != b.size())
        return a.size() > b.size() ? 1 : -1;
    return a.compare(b);
}

/**
 * @brief 相加两个正的十进制大数
 *
 * @param a
 * @param b
 */
static string Add(const std::string &a, const std::string &b)
{
    int i = a.size() - 1, j = b.size() - 1, feed = 0;
    deque<char> dq;
    while (i >= 0 && j >= 0) {
        int x = a[i--] - '0' + b[j--] - '0' + feed;
        dq.push_front(x % 10 + '0');
        feed = x / 10;
    }
    while (i >= 0) {
        int x = a[i--] - '0' + feed;
        dq.push_front(x % 10 + '0');
        feed = x / 10;
    }
    while (j >= 0) {
        int x = b[j--] - '0' + feed;
        dq.push_front(x % 10 + '0');
        feed = x / 10;
    }
    while (feed) {
        dq.push_front(feed % 10 + '0');
        feed /= 10;
    }
    return string(dq.begin(), dq.end());
}

static string Minus(const std::string &a, const std::string &b)
{
    if (a == b)
        return "0";
    assert(dexCompare(a, b) > 0);
    int i = a.size() - 1, j = b.size() - 1, borrow = 0;
    deque<char> dq;
    while (i >= 0 && j >= 0) {
        int x = a[i--] - '0' - (b[j--] - '0') - borrow;
        if (x < 0) {
            borrow = 1;
            x += 10;
        } else
            borrow = 0;
        dq.push_front(x + '0');
    }
    while (i >= 0) {
        int x = a[i--] - '0' - borrow;
        if (x < 0) {
            borrow = 1;
            x += 10;
        } else
            borrow = 0;
        dq.push_front(x + '0');
    }
    while (!dq.empty() && dq.front() == '0')
        dq.pop_front();
    return string(dq.begin(), dq.end());
}

static string Multiply(const std::string &a, int b)
{
    if (a == "0" || b == 0)
        return "0";
    int i = a.size() - 1, feed = 0;
    deque<char> dq;
    while (i >= 0) {
        int x = (a[i--] - '0') * b + feed;
        dq.push_front(x % 10 + '0');
        feed = x / 10;
    }
    while (feed) {
        dq.push_front(feed % 10 + '0');
        feed /= 10;
    }
    return string(dq.begin(), dq.end());
}

static string Multiply(const std::string &a, const std::string &b)
{
    assert(a != "0" && b != "0");
    string res = "0";
    for (int j = b.size() - 1, n = 0; j >= 0; --j, ++n) {
        string temp = Multiply(a, b[j] - '0');
        if (temp != "0") {
            temp += string(n, '0');
            res = Add(res, temp);
        }
    }
    return res;
}

static int tryDivide(const std::string &a, const std::string &b)
{
    assert(dexCompare(a, b + "0") < 0);
    int l = 0, r = 10;
    while (l + 1 < r) {
        int mid = (l + r) / 2;
        dexCompare(Multiply(b, mid), a) > 0 ? r = mid : l = mid;
    }
    return l;
}

static string Divide(const std::string &a, const std::string &b)
{
    assert(!b.empty() && b != "0");
    if (dexCompare(a, b) < 0)
        return "0";

    string curr = b.size() == 1 ? "0" : a.substr(0, b.size() - 1), res;
    size_t p = b.size() - 1;

    while (p < a.size()) {
        if (curr == "0")
            curr = string(1, a[p++]);
        else
            curr.push_back(a[p++]);
        int r = tryDivide(curr, b);
        if (!res.empty() || r)
            res.push_back(r + '0');
        curr = Minus(curr, Multiply(b, r));
    }

    return res;
}
chenjun15
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++大整数类bigInteger及几个重载运算符
Andy__P的博客
05-16 1474
大整数类，重载运算符"<<",">>","!=","+=","+","*",uva424,uva485,uva495,uva324设计大整数类以及几个运算符重载//">>"重载//"<<"重载//"!="重载//"+="重载//"+"重载//"*"重载//uva424主函数//uva495主函数//uva485主函数//uva324主函数 设计大整数...
C++大整数类/高精度类/LargeNum（上万位数秒算）
lixuean0408的博客
01-18 2141
项目名称：C++大整数类开发环境：devc++优化级别：自动C++标准：ISOC++11在我们实际的编程当中，C++自带的整数类型只占用固定的内存，所以变量的最大值和最小值也就是固定的，非常的不妙。即使是最大的unsigned long long，也只能存储2^64-1的数，对于某些算法（例如RSA非对称加密算法），它们需要极大的数据存储量。因此，我就制作了一个大整数类。
C++之大数运算
最新发布
2301_79201049的博客
05-08 1243
我们知道数据类型皆有范围，一旦超出了这个范围就会造成溢出问题今天说说我们常见的数据类型范围：我们平时写代码也会遇到数据类型范围溢出问题：比如 ~ 我们之前写的学生管理系统在用 int类型 填写学生学号时，我们发现了数据溢出那么我们是怎么解决的呢？我们采用了（数组）在我们 C++ 中也就是类型也就是我们可以用字符串类型存储较大的数（会溢出的数据）而字符串的数学运算也被称为大数运算。
构造大数类
04-06
构造大数运算类 +；-；*；/ 并测试。<br>1. 不考虑括号 <br>2. 输入数据最大长度为40 位,要捕获异常 <br>3. 不考虑输入小数部分,<br>4. 测试要完整,先输入两个数,可输出上面两个数的运算结果;<br>5. 需要输出商和余数;
C++大整数类（支持多种进制）
[PE]经典八炮的博客
05-14 6401
一、简介 项目名称：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++ 实现BigInteger 类
热门推荐
Dmaxiya
07-01 1万+
本文提供可复用 C++ BigInteger 类的声明与实现，读者可直接复制使用或从 Github 上获取代码，笔者希望能提供“像使用基本数据类型一样方便”的高精度整数类
简单介绍C++大整数类
m0_65305142的博客
07-02 1845
比如字符串是字符“1234”的组合，通过上述步骤var中得到的是真正int型1234。众所周知有符号的int型最大数据为2147483647（一共10位），所以取BASE为8位，且代码保证进入vector的数据都小于BASE，所以一定不会超限。，作用是将string类型的第一个元素值返回，达到的是一个将C++风格字符串转换为C风格的字符数组的效果。，表示取出原字符串中下标从start开始的长度为n的子字符串，返回值同样是string。同理，取WIDTH为8保证了每一次只录入长度≤8的数据，小于int。
BigInteger 大整数类（C++）
dragonylee的博客
08-10 1069
有时候需要用到大整数，这里放一个自己写的大整数结构体（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++ 大数类
超
04-06 3256
#include #include #include #include #include #include #include #include using namespace std; class integer { friend istream& operator>>(istream& is,integer&); friend ostream& ope
大数类c++大数类
06-05
大数类C++实现详解 大数类是一个重要的数据结构在计算机科学中，它可以用来表示非常大的整数，通常超过了机器字长的限制。在C++中，可以通过重载运算符和实现自定义的整数类来实现大数类。 在这个示例代码中，我们...
c++ 大整数库 big integer
10-15
c++ 大整数库 big integer 来自https://mattmccutchen.net/bigint/
DoubleInt_t:将给定的整数类加倍的 C++ 模板，嵌套时这可以创建大的 bignum
06-07
DoubleInt_t 将给定的整数类加倍的 C++ 模板，嵌套时这可以创建大的 bignum 这开始是模板元编程中的一个有趣的练习。但是优化器可以看到嵌套的类，所以生成的程序集实际上看起来真的有点原生。 特别是因为基类只是 gcc 内联汇编...... 所以，对于小于 1k 位的“小”bignums AKA 来说，我们实际上是一个很好的类。 比 GNU MP 更大且更智能的算法会产生更快的代码。 这也是对你的编译器的一个很棒的测试。 你有没有见过一个模块需要几个小时才能编译？ 好吧，如果整数类型足够大，这可以用这个！！！！！！！ 它还可以创建一些疯狂的大函数……实际上，最新版本的 GCC 编译此代码的能力要强得多（尤其是使用 O3 时比使用旧版本时要强得多）！ 这段代码的优点之一是我创建了一个 x86 int128 类，该类可以提供有关溢出/进位的信息。这个类用作整数倍频器类的
C++大数类封装
03-09
封装好的C++大数类，很全面，包括运算符重载，大数的加、减、乘、除
简单的C++ 大数类
04-18
这个"简单的C++大数类"是作者自定义实现的一个C++库，专门用于处理大数运算。以下是对这个类的一些关键知识点的详细说明： 1. **大数表示**：大数类通常使用数组或链表存储多位数字，每个元素代表一个位。在这个C++...
C++ 大数运算类
06-05
实现各种常用的运算法则，如+、-、*、/、%、++、--、+=、-=、*=、%=、/=、>、<、、>=、==、!=等等 纯面向对象实现，基本上可以代替系统int型使用。
C++实现大数相乘的算法
08-25
在C++编程中，处理大数相乘的问题通常涉及到超出标准整型范围的数值计算。在这种情况下，不能直接使用int、long等基本数据类型来存储和操作这些大数，而需要设计一种算法来模拟数学中的乘法规则。本文将介绍一种基于...
C++ 创建HugeInteger(大整数)类
weixin_74287172的博客
05-20 1355
提供成员函数input(输)、output(输出)、add(加)和substract(减)。为了比较 HugeInteger 对象，提供函数isEqualTo(是等于)isNotEqualTo(是不等于)、isGreaterThan(是大于)、isLessThan(是小于)、isGreaterThanOrEqualTo(是大于等于)和isLessThanOrEqualTo(是小于等于)，这几个函数每个都是“判定”函数，如果两个HugeInteger对象间关系成立，则返回true;
C++ 大整数类（支持上亿个位的整数 '+'、'-'、'*'、'/'、'%'、'^' 计算实现）
weixin_42438777的博客
04-18 2709
C++ 大整数类（支持上亿个位的整数 '+'、'-'、'*'、'/'、'%'、'^' 计算实现） 设计这个类的初衷，来自一次面试，第一个加数是1后面接一千个0，第二个加数是2后面接一千个0，描述这两个数相加的过程，而 int 类型的范围是-2147483648~2147483647，只能接9个0，unsigned long long int 类型也只能保存最大 184467440737095516...
C++大数类实现加减功能
05-09
以下是一个简单的 C++ 大数类实现，它可以实现大数的加减运算： ``` #include #include #include using namespace std; class BigInt { public: string num; BigInt() {} BigInt(string s) { num = s; }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值