大整数类设计（C++）

最新推荐文章于 2024-05-24 09:48:03 发布
最新推荐文章于 2024-05-24 09:48:03 发布
阅读量4.3k 收藏 49
点赞数 7
分类专栏： C++ 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42731435/article/details/112161053
版权

简介

在平时的功能需求中，C/C++语言内置的整形变量表示范围已经足够大了，但是在一些特定的场合，例如解决数学问题的时候，可能需要表示极大的整数。这时候C/C++语言提供的类型就不能满足需求了，需要自己来实现超大整数的实现，当然仅仅是能够存储超大整数还不行，还要能够进行运算。

设计功能

  1. 能够表达正数与负数
  2. 能够由整形或字符串转化得到
  3. 能够使用 + - * / 等符号进行运算
  4. 可以与int 类型进行混合运算
  5. 可以使用输入输出流
  6. 当发生除数为零等错误时会抛出异常

源码分享

头文件：big_int.h

#ifndef BIGINT_H
#define BIGINT_H

#include <iostream>
#include <vector>
using std::istream;
using std::ostream;
using std::string;
using std::vector;
class BigInt {
   public:
    BigInt(long long num = 0);
    explicit BigInt(string str);
    virtual ~BigInt();
    
    int digit_at(size_t index) const;

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

    friend bool operator==(const BigInt& number1, const BigInt& number2);
    friend bool operator!=(const BigInt& number1, const BigInt& number2);
    friend bool operator<(const BigInt& number1, const BigInt& number2);
    friend bool operator>(const BigInt& number1, const BigInt& number2);
    friend bool operator<=(const BigInt& number1, const BigInt& number2);
    friend bool operator>=(const BigInt& number1, const BigInt& number2);

    friend BigInt operator+(const BigInt& number1, const BigInt& number2);
    friend BigInt operator*(const BigInt& number1, const BigInt& number2);
    friend BigInt operator-(const BigInt& number1, const BigInt& number2);
    friend BigInt operator/(const BigInt& number1, const BigInt& number2);
    friend BigInt operator%(const BigInt& number1, const BigInt& number2);
    friend ostream& operator<<(ostream& output, const BigInt& num);
    friend istream& operator>>(istream& intput, BigInt& num);

   private:
    vector<char> number;
    bool negtive;
    static void simple_calc(vector<char>& number1, const vector<char>& number2,
                            bool plus);
    static void add_at(vector<char>& num, int i, unsigned char x);
    static bool greater(const vector<char>& number1, const vector<char>& number2);
};
#endif

源文件：big_int.cpp

#include "big_int.h"
using std::cin;
using std::cout;
using std::endl;

BigInt::BigInt(long long num) {
    negtive = false;
    if (num < 0) {
        num *= -1;
        negtive = true;
    }
    while (num) {
        number.emplace_back(num % 10);
        num /= 10;
    }
    if (number.empty()) {
        number.emplace_back(0);
    }
}

BigInt::BigInt(string str) {
    negtive = false;
    for (int i = str.length() - 1; i >= 0; i--) {
        if (str[i] >= '0' && str[i] <= '9') {
            number.emplace_back(str[i] - '0');
        } else if (i == 0 && str[0] == '-') {
            negtive = true;
        } else {
            break;
        }
    }
    while (number.back() == 0) {
        number.pop_back();
    }
    if (number.empty()) {
        number.emplace_back(0);
        negtive = false;
    }
}
BigInt::~BigInt() {}

int BigInt::digit_at(size_t index) const {
    if (index >= number.size()) {
        throw "Out of range";
    }
    return number[index];
}
void BigInt::add_at(vector<char>& number, int index, unsigned char x) {
    if (x == 0) {
        return;
    }
    int size = number.size();
    if (index >= size) {
        number.insert(number.end(), index - size + 1, 0);
        size = index + 1;
    }
    number[index] += x;
    while (index < size && number[index] >= 10) {
        if (index + 1 == size) {
            number.emplace_back(number[index] / 10);
            size++;
        } else {
            number[index + 1] += number[index] / 10;
        }
        number[index] %= 10;
        index++;
    }
}

BigInt& BigInt::operator=(const BigInt& number2) {
    number = number2.number;
    negtive = number2.negtive;
    return *this;
}
BigInt& BigInt::operator+=(const BigInt& number2) {
    if (negtive != number2.negtive && BigInt::greater(number2.number, number)) {
        BigInt ans = number2;
        BigInt::simple_calc(ans.number, number, false);
        *this = ans;
        return *this;
    }
    BigInt::simple_calc(number, number2.number, negtive == number2.negtive);
    if (number.size() == 1 && number[0] == 0) {
        negtive = false;
    }
    return *this;
}
BigInt& BigInt::operator*=(const BigInt& number2) {
    *this = (*this) * number2;
    return *this;
}
BigInt& BigInt::operator-=(const BigInt& number2) {
    *this = (*this) - number2;
    return *this;
}
BigInt& BigInt::operator/=(const BigInt& number2) {
    *this = (*this) / number2;
    return *this;
}
BigInt& BigInt::operator%=(const BigInt& number2) {
    if (number2 == 0){
        throw "Divide by zero";
    }
    if (BigInt::greater(number2.number, number)) {
        return *this;
    }
    int index = number.size() - number2.number.size();
    while (index >= 0) {
        vector<char> temp(index, 0);
        temp.insert(temp.end(), number2.number.begin(), number2.number.end());
        while (!BigInt::greater(temp, number)) {
            BigInt::simple_calc(number, temp, false);
        }
        index--;
    }
    if (number.size() == 1 && number[0] == 0){
        negtive = false;
    }
    return *this;
}

BigInt& BigInt::operator++() {
    (*this) += 1;
    return *this;
}
BigInt& BigInt::operator--() {
    (*this) -= 1;
    return *this;
}
BigInt BigInt::operator++(int) {
    BigInt temp = (*this);
    (*this) += 1;
    return temp;
}
BigInt BigInt::operator--(int) {
    BigInt temp = (*this);
    (*this) -= 1;
    return temp;
}

bool operator==(const BigInt& number1, const BigInt& number2) {
    if (number1.negtive != number2.negtive) {
        return false;
    }
    return number1.number == number2.number;
}
bool operator!=(const BigInt& number1, const BigInt& number2) {
    return !(number1 == number2);
}
bool operator<(const BigInt& number1, const BigInt& number2) {
    return number2 > number1;
}
bool operator>(const BigInt& number1, const BigInt& number2) {
    if (number1.negtive == false) {
        if (number2.negtive == true) {
            return true;
        } else {
            return BigInt::greater(number1.number, number2.number);  //全为正数
        }
    } else {
        if (number2.negtive == false) {
            return false;
        } else {
            return BigInt::greater(number2.number, number1.number);  //全为负数
        }
    }
}
bool operator<=(const BigInt& number1, const BigInt& number2) {
    return !(number1 > number2);
}
bool operator>=(const BigInt& number1, const BigInt& number2) {
    return !(number1 < number2);
}

BigInt operator+(const BigInt& number1, const BigInt& number2) {
    BigInt ans = number1;
    ans += number2;
    return ans;
}
BigInt operator*(const BigInt& number1, const BigInt& number2) {
    BigInt ans = 0;
    if (number1 == 0 || number2 == 0) {
        return ans;
    }
    ans.negtive = (number1.negtive != number2.negtive);  //同号得正，异号得负
    for (size_t i = 0; i < number1.number.size(); i++) {
        for (size_t j = 0; j < number2.number.size(); j++) {
            BigInt::add_at(ans.number, i + j,
                           number1.number[i] * number2.number[j]);
        }
    }
    return ans;
}

BigInt operator-(const BigInt& number1, const BigInt& number2) {
    BigInt temp = number2;
    temp.negtive = !number2.negtive;  // temp 是number2的相反数
    return operator+(number1, temp);  // n1 - n2 = n1 + (-1 * n2)
}
BigInt operator/(const BigInt& number1, const BigInt& number2) {
    BigInt ans = 0;
    if (number2 == 0){
        throw "Divide by zero";
    }
    if (BigInt::greater(number2.number, number1.number)) {
        return ans;
    }
    ans.negtive = (number1.negtive != number2.negtive);
    vector<char> left = number1.number;
    int index = left.size() - number2.number.size();
    while (index >= 0) {
        vector<char> temp(index, 0);
        temp.insert(temp.end(), number2.number.begin(), number2.number.end());
        while (!BigInt::greater(temp, left)) {
            BigInt::simple_calc(left, temp, false);
            BigInt::add_at(ans.number, index, 1);
        }
        index--;
    }
    return ans;
}
BigInt operator%(const BigInt& number1, const BigInt& number2) {
    BigInt ans = number1;
    ans %= number2;
    return ans;
}
istream& operator>>(istream& in, BigInt& num) {
    string str;
    in >> str;
    num = BigInt(str);
    return in;
}
ostream& operator<<(ostream& out, const BigInt& num) {
    if (num.negtive) {
        out << '-';
    }
    for (int i = num.number.size() - 1; i >= 0; --i) {
        out << (char)(num.number[i] + '0');
    }
    return out;
}

void BigInt::simple_calc(vector<char>& num1, const vector<char>& num2,
                         bool plus) {
    int size1 = num1.size();
    int size2 = num2.size();
    if (plus) {
        for (int i = 0; i < size2; i++) {
            add_at(num1, i, num2[i]);
        }
        return;
    } else {
        for (int i = 0; i < size2; i++) {
            num1[i] -= num2[i];
        }
        for (int i = 0; i < size1; i++) {
            if (num1[i] >= 0) {
                continue;
            }
            char temp = (9 - num1[i]) / 10;
            num1[i + 1] -= temp;
            num1[i] += temp * 10;
        }
        while (size1 > 1 && num1.back() == 0) {
            num1.pop_back();
            size1--;
        }
        return;
    }
}

bool BigInt::greater(const vector<char>& number1, const vector<char>& number2) {
    if (number1.size() != number2.size()) {
        return number1.size() > number2.size();
    }
    for (int i = number1.size() - 1; i >= 0; i--) {
        if (number1[i] != number2[i]) {
            return number1[i] > number2[i];
        }
    }
    return false;
}


int main() {
    BigInt num1, num2;
    while (1) {
        cout << "please enter two long number:" << endl;
        cin >> num1 >> num2;
        cout << "num1 = " << num1 << endl;
        cout << "num2 = " << num2 << endl;

        if (num1 == num2) {
            cout << "num1 == num2" << endl;
        } else if (num1 < num2) {
            cout << "num1 < num2" << endl;
        } else {
            cout << "num1 > num2" << endl;
        }
        cout << "num1 + num2 = " << num1 + num2 << endl;
        cout << "num1 - num2 = " << num1 - num2 << endl;
        cout << "num1 * num2 = " << num1 * num2 << endl;
        cout << "num1 / num2 = " << num1 / num2 << endl;
        cout << "num1 % num2 = " << num1 % num2 << endl;
    }
    
    return 0;
}

试验结果

please enter two long number:
666666   
233
num1 = 666666
num2 = 233
num1 > num2
num1 + num2 = 666899
num1 - num2 = 666433
num1 * num2 = 155333178      
num1 / num2 = 2861
num1 % num2 = 53
please enter two long number:
999999999
-111111111
num1 = 999999999 
num2 = -111111111
num1 > num2      
num1 + num2 = 888888888
num1 - num2 = 1111111110
num1 * num2 = -111111110888888889
num1 / num2 = -9
num1 % num2 = 0
please enter two long number:
0
-5
num1 = 0
num2 = -5
num1 > num2
num1 + num2 = -5
num1 - num2 = 5
num1 * num2 = 0
num1 / num2 = 0
num1 % num2 = 0
please enter two long number:
-4545454545454545
154423
num1 = -4545454545454545
num2 = 154423
num1 < num2
num1 + num2 = -4545454545300122
num1 - num2 = -4545454545608968
num1 * num2 = -701922727272727202535
num1 / num2 = -29435087684
num1 % num2 = -28213
恩基尼尔
关注
  • 7
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2020数据结构课程设计 超长整数四则运算（C语言+双向循环链表）
qq_45572675的博客
12-30 9124
设计题目 任务：设计一个实现任意长的整数进行加法、减法运算的演示程序。 要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。任何整形变量的范围是 -(2^15 - 1)~ (2^15 - 1)。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。 加上前端后的效果 设计过程说明 数据结构是双向循环链表，其结构如图所示。链表中的结点ABC都是0~9999的int类型变量，从低位到高位。即万进制。另外表头结点L用来存储数的符号和结点个数。 对双向循环链表的基本操作有
C++大数BigInt
Happig的博客
07-24 2662
前言 一直在用板子，然后考虑到有些细节还不是很清楚，就整理一下吧。然后没有按板子来写，但是思想基本一致，因为我的板子是每四位合并成一位，也就是将大数看做一个100001000010000进制数 构造和输出 大数一位位地输入比较慢，因此一般采用字符串输入，然后将字符串转化为大数 注意需要从后向前存，运算时从前向后运算，输出时从后向前输出 const int maxn=1005; struct BigInt{ int a[maxn]; int len; BigInt(){ len=1
探索无限可能：C++中的任意大小整数类 BigInt
最新发布
gitblog_00078的博客
05-24 280
探索无限可能：C++中的任意大小整数类 BigInt 项目地址:https://gitcode.com/faheel/BigInt 在编程中处理大数字是常有的挑战，特别是在算法和数学应用中。当标准的int或long long类型无法满足需求时，你需要一个强大的工具来应对这种情况。这就是我们今天要介绍的开源项目——BigInt，一个无额外依赖的现代C++库，用于实现任意大小的整数类。 项目简介 Bi...
C++ 实现BigInteger 类
Dmaxiya
07-01 1万+
本文提供可复用 C++ BigInteger 类的声明与实现，读者可直接复制使用或从 Github 上获取代码，笔者希望能提供“像使用基本数据类型一样方便”的高精度整数类
Bignum-Library:使用C ++创建的“ Bignum”库，可以处理任意大数的算术计算
05-01
比格南图书馆 使用C ++实现的Bignum库。 如果您想修改我的实现，然后检查其正确性，则还包括一个测试套件。 要求 -： GNU C ++编译器 Python解释器（可选；仅用于测试） 测试-： 通过执行test-script文件来启动测试。 去做 -： 将其封装在一个类中。 改进测试程序。 实现更快的乘法和除法算法。
Bignum C++
weixin_30636089的博客
06-16 552
#include <iostream> #include <stdio.h> #include <string> #include <string.h> #include <math.h> #include <queue> #include <memory.h> using namespace s...
c++大整数类的几种实现方法与解析
热门推荐
dvt777的博客
10-04 1万+
在oj上做题时，相信大家遇到过很多要求大整数的题目，这时候，我们就需要用到所谓的高精度算法，即用数组来储存整数，模拟四则运算以及其他常见的运算，下面就让我们来分析一下几种实现大整数的方法 一.用vector来储存大整数 #include #include #include #include #include #include using namespace std; class Big
C++小项目之大数相加减
程序员的规则
11-28 611
#pragma once #ifndef BIG_NUM_H//防止重定义 #define BIG_NUM_H #include<iostream> #include<string> using namespace std; class BigNum { public: BigNum(int num = 0); BigNum(const string& str); BigNum(const BigNum& src); BigNum& operator
C++大整数类
04-13
本示例中的"C++大整数类"就是这样一个类，用于存储和操作任意位数的整数。这里我们将深入讨论大整数类的设计、实现以及如何使用它来计算100内的质数之和。 首先，`BigInt.h` 文件通常会定义大整数类的接口，包括...
大整数计算器（c++）
06-08
我自己的课设，大二写的，98分 加减乘除法都有
大整数类 C++ 程序设计
04-01
程序设计的作业，使用C++编写大整数类。
大整数类C++实现（绝对可用）
06-30
大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）
C++ BigInt class:C ++ BigInt类可以使用任意精度的整数-开源
04-26
C ++ BigInt类，使用户能够使用任意精度的整数。 最新版本：10.3（2019-03-06）
高精度大整数加法C++实现
01-06
该资源通过C++代码实现两个大整数的相加，适用于当long long也存不下的数进行相加时使用，通过数组模拟算术加法实现，运行时只需输入两个加数，敲回车即可出结果
大整数类bigint
07-16
大整数类bigint，包含大整数的加法、乘法、除法等运算
Bigint大整数类
07-16
包含大整数的各种运算函数，如加法、减法、乘法、除法、取余等
C++实现大整数乘法
08-25
由于大整数的存在，普通的整数乘法算法无法满足要求，因此需要专门设计大整数乘法算法。在C++中实现大整数乘法可以使用笛卡尔相乘法，这种方法将大整数看作多项式的系数，然后对应相乘相加。 大整数乘法的实现可以...
C++实现的大整数四则运算
12-25
首先，我们来看大整数类的设计。在C++中，大整数通常通过数组或向量存储，每个元素表示数字的一个位。数组或向量的长度可以动态调整，以适应任意大小的整数。大整数类可能包含以下主要成员： 1. **数据成员**：一个...
HDU 1134 大数取模 使用大数模板
vsooda的专栏
01-25 4607
#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

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值