cpp 大整数类示例，加减乘除

于 2024-08-03 06:04:46 发布
阅读量86 收藏
点赞数
分类专栏： 笔记 文章标签： c++ 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovefor999/article/details/140884358
版权

注：练手写的，写的比较简单，只考虑正数。没考虑运算速度。0做除数时不抛出异常或终止程序，而是返回0。取模、逻辑运算符、自增自减、位运算和一些其他的运算符没有处理。
加注释是有部分修改，可能无法运行
BigInt.h

#ifndef H_BIGINT
#define H_BIGINT

#include<vector>
#include<string>
#include<algorithm>
#include<iostream>

class BigInt{
private:
    std::vector<int> digits;  //储存每一位
public:
    BigInt();//空白构造函数
    BigInt(long long);//正数转大整数
    BigInt(const BigInt &);//拷贝构造函数
    BigInt(const BigInt & b, int s1, int s2);// 取b的第s1位到第s2位
    BigInt(const std::string&);//字符串装大整数
    //重载赋值运算符
    BigInt & operator=(long long);
    BigInt & operator=(const std::string&);
    BigInt & operator+=(const BigInt b);
    BigInt & operator-=(const BigInt b);
    BigInt & operator*=(const BigInt b);
    BigInt & operator/=(const BigInt b);
    BigInt & operator>>=(unsigned int n);
    BigInt & operator<<=(unsigned int n);

    friend std::istream & operator>>(std::istream &,BigInt &);//重载输入运算符>>
    friend std::ostream & operator<<(std::ostream &,const BigInt &);//重载输出运算符<<

    // 重载比较运算符
    bool operator==(const BigInt & b) const;
    bool operator!=(const BigInt & b) const;
    bool operator>=(const BigInt & b) const;
    bool operator<=(const BigInt & b) const;
    bool operator>(const BigInt & b) const;
    bool operator<(const BigInt & b) const;

    bool isZero()const;  // 判断自身是否为0
    int size()const;  // 输出数字位数
    int length()const;  // =size()
    
    int at(unsigned int n)const;  // 获取从高位到低位的第n+1位数，从0开始，超范围返回-1
    int operator[](unsigned int n)const;/  / 获取从高位到低位的第n+1位数，从0开始，不检查是否超范围，可能出现编译正常，运行出错的情况


    // 重载算数运算符
    BigInt addOne(int n) const;
    BigInt operator+(const BigInt & b) const;
    BigInt operator-(const BigInt & b) const;
    BigInt mulOne(int n) const;  // BigInt 与 一位数 相乘
    BigInt operator*(const BigInt & b) const;  // BigInt 与 BigInt 相乘
    BigInt operator/(const BigInt & b) const;
    BigInt operator>>(unsigned int n) const;
    BigInt operator<<(unsigned int n) const;
    
    friend BigInt operator+(unsigned long long a, const BigInt & b);
    friend BigInt operator-(unsigned long long a, const BigInt & b);
    friend BigInt operator*(unsigned long long a, const BigInt & b);
    friend BigInt operator/(unsigned long long a, const BigInt & b);

};
class SignBigInt{
private:
    BigInt num;
    bool posi;
public:
    // 留空
};
#endif

BigInt.cpp


#include"BigInt.h"

BigInt::BigInt(){}
BigInt::BigInt(long long l){*this = l;}
BigInt::BigInt(const BigInt & a){digits.assign(a.digits.begin(),a.digits.end());}
BigInt::BigInt(const BigInt & a, int s1, int s2){
    digits.assign(a.digits.begin()+s1,a.digits.begin()+s1+s2);
}
BigInt::BigInt(const std::string& s){*this = s;}
BigInt & BigInt::operator=(long long l){
    digits.clear();
    for(;l>0;l/=10){
        digits.push_back((int)(l%10));
    }
    std::reverse(digits.begin(),digits.end());
    return *this;
}
BigInt & BigInt::operator=(const std::string& s){
    digits.clear();
    for(size_t i=0;i<s.size();++i){
        digits.push_back((int)(s.at(i)-'0'));
    }
    return *this;
}
std::istream & operator>>(std::istream & i,BigInt & a){
    std::string s;i >> s;a = s;
    if(a.digits[0] == 0) {
        auto it = find_if(a.digits.begin(),a.digits.end(),[](int x){ return x != 0;});
        a.digits.erase(a.digits.begin(), it);
    }
    return i;
}
std::ostream & operator<<(std::ostream & o,const BigInt & b){
    if(b.isZero()) o << "0";
    else for(int n:b.digits){o << n;}
    return o;
}
bool BigInt::operator==(const BigInt & b) const{
    if(digits.size()!=b.digits.size()){return false;}
    else if(digits != b.digits){return false;}
    else {return true;}
}
bool BigInt::operator!=(const BigInt & b) const{
    if(digits.size()!=b.digits.size()){return true;}
    else if(digits != b.digits){return true;}
    else {return false;}
}
bool BigInt::operator>=(const BigInt & b) const{
    if(digits.size()<b.digits.size()){return false;}
    else if(digits < b.digits){return false;}
    else {return true;}
}
bool BigInt::operator<=(const BigInt & b) const{
    if(digits.size()>b.digits.size()){return false;}
    else if(digits > b.digits){return false;}
    else {return true;}
}

bool BigInt::operator>(const BigInt & b) const{
    if(digits.size() < b.digits.size()){return false;}
    else if(digits.size() > b.digits.size()){return true;}
    else {
        for(size_t i=0;i<digits.size();++i){
            if(digits[i]<b.digits[i]) return false;
        }
        return true;
    }
}
bool BigInt::operator<(const BigInt & b) const{
    if(digits.size() > b.digits.size()){return false;}
    else if(digits.size() < b.digits.size()){return true;}
    else {
        for(size_t i=0;i<digits.size();++i){
            if(digits[i]>b.digits[i]) return false;
        }
        return true;
    }
}

bool BigInt::isZero()const{return digits.size()==0;}
int BigInt::size()const{return digits.size()?digits.size():1;}
int BigInt::length()const{return size();}
int BigInt::at(unsigned int n)const{
    if(n<size()) return digits[n];
    else return -1;
}
int BigInt::operator[](unsigned int n)const{
    return digits[n];
}

BigInt BigInt::addOne(int n) const{
    BigInt a,b=*this;
    reverse(b.digits.begin(),b.digits.end());
    if(b.digits.size()==0){a=n;}
    else if(n==0){a=b;}
    else{
        int carry=0,sum=0;
        for(int i=0;i<digits.size();++i){
            sum = n + digits[i] + carry;
            carry = sum/10;
            a.digits.push_back(sum%10);
        }
        while(carry>0){
            a.digits.push_back(carry);
            carry/=10;
        }
    }
    reverse(a.digits.begin(),a.digits.end());
    if(a.digits[0] != 0) return a;
    auto it = find_if(a.digits.begin(),a.digits.end(),[](int x){ return x != 0;});
    a.digits.erase(a.digits.begin(), it);
    return a;
}

BigInt BigInt::operator+(const BigInt & bi) const{
    BigInt c;
    if(digits.size()==0){c=bi;return c;}
    else if(bi.digits.size()==0){return *this;}
    else {
        BigInt a = *this,b = bi;
        reverse(a.digits.begin(),a.digits.end());
        reverse(b.digits.begin(),b.digits.end());
        int carry=0,sum=0;
        int s1 = a.digits.size(),s2 = b.digits.size();
        if(s1 <= s2){
            for(int i=0;i<s1;++i){
                sum = carry+a.digits[i]+b.digits[i];
                carry = sum/10;
                c.digits.push_back(sum%10);
            }
            for(int i=s1;i<s2;++i){
                sum = carry + b.digits[i];
                carry = sum/10;
                c.digits.push_back(sum%10);
            }
            while(carry>0){
                c.digits.push_back(carry);
                carry/=10;
            }
        } else {
            for(int i=0;i<s2;++i){
                sum = carry+a.digits[i]+b.digits[i];
                carry = sum/10;
                c.digits.push_back(sum%10);
            }
            for(int i=s2;i<s1;++i){
                sum = carry + a.digits[i];
                carry = sum/10;
                c.digits.push_back(sum%10);
            }
            while(carry>0){
                c.digits.push_back(carry);
                carry/=10;
            }
        }
    }
    reverse(c.digits.begin(),c.digits.end());
    if(c.digits[0] != 0) return c;
    auto it = find_if(c.digits.begin(),c.digits.end(),[](int x){ return x != 0;});
    c.digits.erase(c.digits.begin(), it);
    return c;
}


BigInt BigInt::operator-(const BigInt & bi) const{
    BigInt a=*this,b=bi,c;
    int carry = 0,sub = 0,i=0;
    int s1 = a.digits.size(), s2 = b.digits.size(),s3=0;
    if(s1 == s2){
        if(a.digits == b.digits) return BigInt();
        else if(a.digits > b.digits){
            for(i=s1-1;i>=0;--i){
                sub = a.digits[i] - b.digits[i] - carry;
                if(sub < 0){sub += 10;carry = 1;}
                else {carry = 0;}
                c.digits.push_back(sub);
            }
        } else {
            for(i=s2-1;i>=0;--i){
                sub = b.digits[i] - a.digits[i] - carry;
                if(sub < 0){sub += 10;carry = 1;}
                else {carry = 0;}
                c.digits.push_back(sub);
            }
        }
        
    }else if(s1 > s2){
        s3 = s1 - s2;
        for(i=s1-1;i>=s3;--i){
            sub = a.digits[i] - b.digits[i-s3] - carry;
            if(sub < 0){sub += 10;carry = 1;}
            else {carry = 0;}
            c.digits.push_back(sub);
        }
        while(i >= 0){
            sub = a.digits[i] - carry;
            if(sub < 0){sub += 10;carry = 1;}
            else {carry = 0;}
            c.digits.push_back(sub);
            --i;
        }
    } else {
        s3 = s2 - s1;
        for(i=s2-1;i>=s3;--i){
            sub = b.digits[i] - a.digits[i-s3] - carry;
            if(sub < 0){sub += 10;carry = 1;}
            else {carry = 0;}
            c.digits.push_back(sub);
        }
        while(i >= 0){
            sub = b.digits[i] - carry;
            if(sub < 0){sub += 10;carry = 1;}
            else {carry = 0;}
            c.digits.push_back(sub);
            --i;
        }
    }
    reverse(c.digits.begin(),c.digits.end());
    if(c.digits[0] != 0) return c;
    auto it = find_if(c.digits.begin(),c.digits.end(),[](int x){ return x != 0;});
    c.digits.erase(c.digits.begin(), it);
    return c;
}

BigInt BigInt::mulOne(int n) const{
    BigInt a = *this;
    reverse(a.digits.begin(),a.digits.end());
    int carry = 0, mul = 0;
    for(int i=0;i<a.digits.size();++i){
        mul = carry + a.digits[i]*n;
        carry = mul / 10;
        a.digits[i] = mul % 10;
    }
    while(carry){ a.digits.push_back(carry);carry/=10;}
    reverse(a.digits.begin(),a.digits.end());
    return a;
}

BigInt BigInt::operator*(const BigInt & bi) const{
    if(isZero() || bi.isZero()) return BigInt();  // 如果两个数中有0，则相乘结果为0
    BigInt re;
    int scale = 1;
    if(digits.size() > bi.digits.size()){
        for(int i=bi.digits.size()-1;i>=0;--i)
            re = re + mulOne(bi.digits[i]*scale);
        scale += 10;
    } else {
        for(int i=digits.size()-1;i>=0;--i)
            re = re + bi.mulOne(digits[i]*scale);
        scale += 10;
    }
    return re;
}
BigInt BigInt::operator/(const BigInt & b) const{
    // 如果除数或被除数为0，返回0 !!！ 除数为0时未抛出异常
    if(b.isZero() || isZero()) return BigInt(); 
    if(*this < b) return 0; 
    else if(*this == b) return 1;
    else{
        BigInt ret,tmp;
        int s1 = size(),s2 = b.size(),s3,dig=0;
        s3 = s1 - s2;
        for(int i=0;i<=s3;++i){
            if(tmp == 0) {tmp = BigInt(*this, i, s2);
            } else {
                tmp.digits.push_back(digits[s2+i-1]);
            }
            dig = 0;
            if(tmp < b){ret.digits.push_back(dig);}
            else {
                while(tmp > b){
                    tmp = tmp - b;
                    dig += 1;
                }
                ret.digits.push_back(dig);
            }
        }
        if(ret.digits[0] != 0) return ret;
        auto it = find_if(ret.digits.begin(),ret.digits.end(),[](int x){ return x != 0;});
        ret.digits.erase(ret.digits.begin(), it);
        return ret;
    }
}

BigInt operator>>(unsigned int n) const{
    if(n>=size()) return BigInt();
    else {
        BigInt re = *this;
        re.digits.assign(re.digits.begin(),re.digits.begin()+size()-n);
        return re;
    }
}
BigInt operator<<(unsigned int n) const{
    if(isZero()) return BigInt();
    else{
        BigInt re = *this;
        // while(n--){re.digits.push_back(0);}
        re.digits.insert(re.digits.end(), n, 0);
        return re;
    }
}

BigInt operator+(unsigned long long a, const BigInt & b){return (b+a);}
BigInt operator-(unsigned long long a, const BigInt & b){return (BigInt(a)-b);}
BigInt operator*(unsigned long long a, const BigInt & b){return (b*a);}
BigInt operator/(unsigned long long a, const BigInt & b){return (BigInt(a)/b);}

BigInt & BigInt::operator+=(const BigInt b){*this = *this + b;return *this;}
BigInt & BigInt::operator-=(const BigInt b){*this = *this - b;return *this;}
BigInt & BigInt::operator*=(const BigInt b){*this = *this * b;return *this;}
BigInt & BigInt::operator/=(const BigInt b){*this = *this / b;return *this;}
BigInt & BigInt::operator>>=(unsigned int n){
    // *this = *this >> n;
    if(n>=size()){digits.clear();}
    else {digits.assign(digits.begin(),digits.begin()+size()-n);}
    return *this;
}
BigInt & BigInt::operator<<=(unsigned int n){
    if(!isZero()){
        // while(n--){digits.push_back(0);}
        digits.insert(digits.end(), n, 0);
    }
    return *this;
}

一个测试示例main.cpp

#include"BigInt.h"

using namespace std;

int main(){
    BigInt a(0),b(2);
    cout << "0/2=" << (a/b) << endl;
    a = 8,b = 2;
    cout << "8/2=" << (a/b) << endl;
    a = 15,b = 4;
    cout << "15/4=" << (a/b) << endl;
    a = 15,b = 0;
    cout << "15/0=" << (a/b) << endl;
    a = 128,b = 11;
    cout << "128/11=" << (a/b) << endl;
    a = 1100,b = 9;
    cout << "1100/9=" << (a/b) << endl;
    a = 15,b = 20;
    cout << "15/20=" << (a/b) << endl;

    
    // cout << "111" << endl;
    // BigInt a(123),b("124"),c;
    // cout << "a=" << a << endl;
    // cout << "b=" << b << endl;
    // cout << "a+b=" << (a+b) << endl;
    // cout << "a-b=" << (a-b) << endl;
    // cout << "b-a=" << (b-a) << endl;
    // cout << "b*9=" << (b*9) << endl;
    // cout << "9*b=" << (9*b) << endl;
    // cout << "b+9=" << (b+9) << endl;
    // cout << "9+b=" << (9+b) << endl;
    // cout << "b-9=" << (b-9) << endl;
    // cout << "9-b=" << (9-b) << endl;
    // if(a<b)cout << "a<b" << endl;
    // if(a>b)cout << "a>b" << endl;
    // if(a<=b)cout << "a<=b" << endl;
    // if(a>=b)cout << "a>=b" << endl;


    // BigInt a(123);
    // a = 444;
    // cout << a << endl;
    // a = "555";
    // cout << a << endl;
    // BigInt b(123);
    // cout << b << endl;
    // BigInt c("123");
    // cout << c << endl;
    // BigInt d(c);
    // cout << d << endl;
    // BigInt e=d;
    // cout << d << endl;
    // BigInt f(111);
    // cout << f << endl;
    // f = d;
    // cout << f << endl;
    return 0;
}
今夕何夕2112
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
大整数加减乘除运算
05-23
本项目主要关注大整数的加减乘除运算的实现，这涉及到数据结构和算法的设计。以下是对这个课程设计项目的详细解读。 首先，我们要理解大整数的概念。在常规的计算机编程中，整数的大小受到数据类型限制，例如，int...
C++ 实现大整数的加减乘除运算
06-11
### C++实现大整数的加减乘除运算 #### 概述 本文将详细介绍一个C++类`bign`的设计与实现，该类能够处理超出标准整型数据类型范围的大整数运算，包括加法、减法、乘法、除法等基本运算。这个类在实现时考虑到了内存...
C++用运算符重载实现有理数类，进行分数的加减乘除输入输出，完整过程和代码
qq_61845364的博客
05-03 2581
我们从新建项目开始，想要代码的话在后面可以直接跳过前面。代码是超级完整的代码嗷，可能没有大佬的优化好，但是初学者（像我）应该挺好理解的！class Rational { public: Rational(); Rational(int); Rational(int, int); ~Rational(); void simplify(); //约分 friend void sameDenomination(Rational a, Rational b); //通分
【剑指 Offer 65. 不用加减乘除做加法】
是小武呀
02-21 339
【剑指 Offer 65. 不用加减乘除做加法】题目描述：示例：解析思路1：代码（cpp）代码（python） 题目描述： 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/bu-yong-jia-jian-cheng-chu-zuo-jia-fa-lcof/ 写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。 示例： 示例1： 输入: a = 1, b = 1 输出: 2 提示：
CPP剑指 Offer 65. 不用加减乘除做加法
beidoubushixing的博客
07-11 151
题目描述： 写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。 示例: 输入: a = 1, b = 1 输出: 2 提示： a, b 均可能是负数或 0，结果不会溢出 32 位整数 解题思路 不能使用加减乘除四则运算，所以只能返本溯源想到使用二进制的位运算实现相加操作。 二进制位运算中，异或操作: 1^1=0 0^0=0 1^0=1 0^1=1，可以模拟无进位的加操作； 与操作：1&1=1 0&1=0 1&0=0 0&0=0，
vs2017\vs2019 构造有理数类实现加减乘(除)四则运算
黄笳倞的博客
02-22 8966
这是针对于博客vs2017安装和使用教程（详细）和vs2019安装和使用教程（详细）的构造有理数类实现加减乘（除）四则运算的新建示例 目录 一、项目结构 二、代码 三、运行结果 四、注意事项 一、项目结构 1.头文件 CRation.h 2.源文件 CRation.cpp main.cpp ...
Powerful Calculator（带符号的大整数的加减乘）
qq_30339595的博客
03-01 356
时间限制：1秒 空间限制：65536K 热度指数：393 算法知识视频讲解题目描述    Today, facing the rapid development of business, SJTU recognizes that more powerful calculator should be studied, developed and appeared in future market s...
C++实现大整数计算器（高精度加减乘除）——————极易理解，源码直用
Main666的博客
11-14 1103
C++语言不像python等语言，由于其天然的特性，可以支持超大整数的计算。C++的最大整型long long范围仅有-9223372036854775808到9223372036854775807这显然无法满足某些情况下的需要，但是我们可以将超大整数存入数组，模拟加减乘除的过程，进而计算结果。以上就是今天要讲的内容，本文仅仅简单介绍了C++高精度计算的一种实现方法，后续可以开发C++专属的大整数类来进一步方便使用。
Qt新手入门级 计算器加、减、乘、除、应用
weixin_44759598的博客
07-04 771
Qt新手入门级 计算器加、减、乘、除、应用
使用C++编写的简单示例，实现一个计算器，支持加减乘除四则运算
m0_74288308的博客
05-02 1883
在add()函数中，我们计算a和b的和。在subtract()函数中，我们计算a和b的差。在multiply()函数中，我们计算a和b的积。在divide()函数中，我们首先判断除数是否为0，如果为0则返回0，否则计算a和b的商。在main()函数中，我们创建一个Calculator对象，然后分别进行加法、减法、乘法和除法的计算，并输出结果。在Calculator类中，我们声明了构造函数、加法、减法、乘法和除法的成员函数。1.使用C++编写的简单示例，实现一个计算器，支持加减乘除四则运算。
LeetCode 371.两整数之和 (C/C++)
Seven
06-19 2847
LeetCode 371.两整数之和 题目描述 不使用运算符+和-​​​​​​​，计算两整数 ​​​​​​​a、b​​之和。 示例 示例 1: 输入: a = 1, b = 2 输出: 3 示例 2: 输入: a = -2, b = 3 输出: 1 分析 第一眼看到题目就心想，这不是很简单么，异或、位运算，不就行了
cpp代码-RSA破译
07-16
1. 大数运算：由于RSA涉及到大整数的加减乘除和幂运算，因此在C++中需要使用大数库，比如GMP或内置的大整数类型（如long long，但通常不够大）。 2. 素数测试：为了生成RSA密钥对，需要找到两个大素数p和q，这通常...
在二元域内实现加法 乘法
01-29
在二元域（通常指的是GF(2^n)，其中n是正整数）中，加法操作实际上就是一个异或运算（XOR）。这是因为二元域中的元素只有0和1，0+0=0，0+1=1，1+0=1，1+1=0，这与异或运算的规则完全吻合。以下是C语言实现的一个简单...
cryptography-in-c-cpp-master.zip
09-07
在密码学中，大整数的加减乘除、模运算以及因数分解等是常见操作。Flint使用了高效的位操作技术，使得这些运算能在合理的时间内完成，这对于需要处理大量加密数据的系统来说至关重要。例如，RSA公钥加密算法就依赖于...
【C++】输入输出
最新发布
2401_83948390的博客
08-02 207
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
【2024蓝桥杯/C++/B组/传送阵】
m0_73669127的博客
07-30 362
【代码】2024蓝桥杯/C++/B组/传送阵。
第六章 - c语言中的数组-二维数组（下）
百知_zmj的博客
08-02 153
二维数组案例：杨辉三角形。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 478
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
实数矩阵类的加减乘除运算的实现C++
05-30
以下是一个简单的实数矩阵类的加减乘除运算的实现示例： ```cpp #include #include using namespace std; class Matrix { public: Matrix(int rows, int cols) { this->rows = rows; this->cols = cols; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今夕何夕2112

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值