大整数加减法（C++实现）

最新推荐文章于 2024-02-09 14:57:27 发布
最新推荐文章于 2024-02-09 14:57:27 发布
阅读量5.4k 收藏 10
点赞数 2
分类专栏： 编程 字符串 文章标签： 大整数加减法实现 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TQH_Candy/article/details/52216916
版权

 头文件：LargeInteger.h

#ifndef LARGEINTEGER_H_INCLUDED
#define LARGEINTEGER_H_INCLUDED

#include <iostream>

using namespace std;

class LargeInteger {// 大整数（用字符串表示）
public:
    LargeInteger() { this->numStr = "0"; }// 默认为 0
    LargeInteger(const string& numStr);// 用字符串初始化
    LargeInteger(const int& num);//　用　int 型数据初始化
    string getNum() const { return numStr; }
    void setNum(const string& numStr);
    void setNum(const int& num);
    void trimNum();// 去掉数字前面所有的 0
    friend bool isNum(const string& numStr);
    friend istream& operator>>(istream& in, LargeInteger& largeInteger);
    friend ostream& operator<<(ostream& out, const LargeInteger& largeInteger);
    friend const LargeInteger operator+(const LargeInteger& A, const LargeInteger& B);
    friend const LargeInteger operator-(const LargeInteger& A, const LargeInteger& B);
private:
    string numStr;
};

#endif // LARGEINTEGER_H_INCLUDED


源文件：LargeInteger.cpp

#include "LargeInteger.h"
#include <sstream>

bool isNum(const string& numStr) { // 判断一个 string 型的 numStr 里面存放的是不是表示的一个整数
    if(numStr.empty()) return false;
    if('-' == numStr[0] || '+' == numStr[0]) {
        if(1 == numStr.size()) return false;
    }
    for(string::size_type i=1; i < numStr.size(); i++) {
        if(numStr[i] < '0' || numStr[i] > '9')
            return false;
    }
    return true;
}

void LargeInteger::trimNum() {// 去掉数字前面所有的 0 字符
    string sign = "";
    string::size_type beginIndex = 0;
    if('-' == this->numStr[0]) {
        sign = "-";
        beginIndex++;
    }
    for(; beginIndex < this->numStr.size(); beginIndex++) {
        if('0' != this->numStr[beginIndex])
            break;
    }
    if(numStr.size() == beginIndex)
        this->numStr = "0";
    else
        this->numStr = sign + this->numStr.substr(beginIndex);
}

LargeInteger::LargeInteger(const string& numStr) {
    this->setNum(numStr);
}

LargeInteger::LargeInteger(const int& num) {
    this->setNum(num);
}

void LargeInteger::setNum(const string& numStr) {
    if(isNum(numStr)) {
        if('+' == numStr[0])
            this->numStr = numStr.substr(1);
        else
            this->numStr = numStr;
    } else
        this->numStr = "0";
    this->trimNum();
}

void LargeInteger::setNum(const int& num) {
    stringstream ss;
    ss << num;
    this->numStr = ss.str();
}

istream& operator>>(istream& in, LargeInteger& largeInteger) {
    in >> largeInteger.numStr;
    if(isNum(largeInteger.numStr)) {
        if('+' == largeInteger.numStr[0])
            largeInteger.numStr = largeInteger.numStr.substr(1);
    } else
        largeInteger.numStr = "0";
    largeInteger.trimNum();
    return in;
}

ostream& operator<<(ostream& out, const LargeInteger& largeInteger) {
    out << largeInteger.numStr;
    return out;
}

void Add(string& sumStr, string aStr, int lengthA, string bStr, int lengthB) {// 两正整数相加
    int n = lengthA;
    if(lengthA < lengthB) {
        n = lengthB;
        aStr = string(n - lengthA, '0') + aStr;
    } else {
        bStr = string(n - lengthB, '0') + bStr;
    }
    int carry = 0;
    while(--n >= 0) {
        int a = aStr[n] - '0';
        int b = bStr[n] - '0';
        int sum = a + b + carry;
        carry = sum / 10;
        sum %= 10;
        char c = sum + '0';
        sumStr = c + sumStr;
    }
    if(carry > 0) {
        char c = carry + '0';
        sumStr = c + sumStr;
    }
}

LargeInteger const operator+(const LargeInteger& A, const LargeInteger& B) {
    string sumStr = "";
    int lengthA = A.numStr.size();
    int lengthB = B.numStr.size();
    if('0' <= A.numStr[0] && A.numStr[0] <= '9' && '0' <= B.numStr[0] && B.numStr[0] <= '9') {// 两正整数相加
        Add(sumStr, A.numStr, lengthA, B.numStr, lengthB);
    } else if('-' == A.numStr[0] && '-' == B.numStr[0]) {// 两负整数相加
        Add(sumStr, A.numStr.substr(1), --lengthA, B.numStr.substr(1), --lengthB);
        sumStr = "-" + sumStr;
    } else if('-' == A.numStr[0]) {
        string temp = A.numStr.substr(1);
        return (B - temp);
    } else {
        string temp = B.numStr.substr(1);
        return (A - temp);
    }
    return sumStr;
}

void Minus(string& minusStr, string aStr, int lengthA, string bStr, int lengthB) {// 两正整数相减
    bool flag = true;// 默认符号位为正
    if(lengthA < lengthB || (lengthA == lengthB && aStr[0] < bStr[0])) {// 如果 A <= B，则计算 B-A，并设置符号位为负
        string tempStr = aStr;
        aStr = bStr;
        bStr = tempStr;
        lengthA = aStr.size();
        lengthB = bStr.size();
        flag = false;
    }
    int n = lengthA;
    bStr = string(n - lengthB, '0') + bStr;
    int borrow = 0, index = n;
    while(--n >= 0) {
        int a = aStr[n] - '0';
        if(a > 0) {
            a -= borrow;
            borrow = 0;
        } else {
            if(borrow > 0)
                a = 9;
        }
        int b = bStr[n] - '0';
        char c;
        if(0 == b) {
            c = a + '0';
        } else {
            if(a >= b) {
                c = a - b + '0';
            } else {
                a += 10;
                c = a - b + '0';
                borrow++;
            }
        }
        minusStr = c + minusStr;
        if(minusStr[0] != '0')
            index = n;
    }
    if(index == n)
        minusStr = "0";
    else {
        minusStr = minusStr.substr(index);
        if(!flag) {
            minusStr = "-" + minusStr;
        }
    }
}

LargeInteger const operator-(const LargeInteger& A, const LargeInteger& B) {
    string minusStr = "";
    int lengthA = A.numStr.size();
    int lengthB = B.numStr.size();
    if('0' < A.numStr[0] && A.numStr[0] <= '9' && '0' < B.numStr[0] && B.numStr[0] <= '9') {// 两正整数相减
        Minus(minusStr, A.numStr, lengthA, B.numStr, lengthB);
        return minusStr;
    } else if('-' == A.numStr[0] && '-' == B.numStr[0]) { // 两负整数相减
        Minus(minusStr, A.numStr.substr(1), lengthA-1, B.numStr.substr(1), lengthB-1);
        if('-' == minusStr[0])
            minusStr = minusStr.substr(1);
        else
            minusStr = "-" + minusStr;
        return minusStr;
    } else {
        if('-' == B.numStr[0]) {// 正整数减负整数（即，两正整数相加）
            Add(minusStr, A.numStr, lengthA, B.numStr.substr(1), lengthB-1);
            return minusStr;
        } else { // 负整数减正整数（即，负的 两正整数相加）
            Add(minusStr, A.numStr.substr(1), lengthA-1, B.numStr, lengthB);
            minusStr = "-" + minusStr;
            return minusStr;
        }
    }
}

主函数测试： 

#include "LargeInteger.h"

int main() {
    LargeInteger A, B;
    LargeInteger C(145265555), D(145325563);
    LargeInteger E("12345678912345678145912345678987654321"), F("15483395674458414455268441265444556845555445677");

    cin >> A >> B;
    cout << A << " + " << B << " = " << A + B << endl;
    cout << A << " - " << B << " = " << A - B << endl;

    cout << C << " + " << D << " = " << C + D << endl;
    cout << C << " - " << D << " = " << C - D << endl;

    cout << E << " + " << F << " = " << E + F << endl;
    cout << E << " - " << F << " = " << E - F << endl;
    return 0;
}


Hot Autumn
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用LARGE_INTEGER查看系统运行时间
07-03
windows ce是一个实时操作,因此提供了不少的优先级给用户.优先级最高为0级,也就是说使用0优先级的程序, 可以挂起整个系统, 来运行你的程序 对于实时性比较的领域, 我们作为程序员的 应该清楚的知道你的程序模块运行的时间 是非常必要的. 当然这个模块运行的时间也不是完全的稳定的, 几次运行的时间相差几十毫秒是很正常的. 因此我们只要知道大概的时间就可以了.
C++实现大数运算（加减乘除求余）
热门推荐
cai_niaocainiao的博客
08-08 2万+
前言： 只有部分GCC编译器支持int128，而我们平常使用的软件，最大只有_int64.当这些不够用时，我们该怎么办？ 我本身想写代码实现整数型大数据的加减乘除和求余，结果写着写着想着连小数运算的也一起写上（反正加的代码不多） 电脑是死的，人是活的，当数据超出范围时，我们可以想其他方法去算，在这里，我使用string类来存数据，string类的容量足够大，相信够一般大数据使用了吧。 编译软...
【转】[C++]LARGE_INTEGER 类型使用
Qsir的专栏
06-01 6898
这里解释前面碰到的LARGE_INTEGER结构。与可能的误解不同，64位数据并非要在64位操作系统下才能使用。在VC中，64位数据的类型为__int64。定义写法如下：       __int64 file_offset;       上面之所以定义的变量名为file_offset，是因为文件中的偏移量是一种常见的要使用64位数据的情况。同时，文件的大小也是如此（回忆上一
C++大整数加法(易懂)
最新发布
2301_79946270的博客
02-09 1165
C++大整数计算（易懂）
大数运算-减法（C/C++实现）
shayuanshayuan_的博客
07-22 1万+
大数运算-减法 前言 上一篇中已经介绍了大数运算的加法（如果没有看过上一篇，请先看一下上一篇，再继续看关于减法的讲解），是通过模拟列竖式的计算实现的，大数运算的减法实际上也是通过模拟列竖式来进行计算的，只是把‘+’号变成了‘-’号，进位变成了借位，接下来，让我们开始吧。 问题分析 和加法一样，首先我们先给定一组数据，来辅助说明整个计算过程，在减法中，可能会出现一个小的数字减去一个
C++学习（八十五）LARGE_INTEGER提供64位整数
hankern的专栏
05-20 448
提供64位整数 1、定义 typedef union _LARGE_INTEGER { struct { DWORD LowPart; LONG HighPart; } DUMMYSTRUCTNAME; struct { DWORD LowPart; LONG HighPart; } u; LONGLONG QuadPart; } LARGE_INTEGER; 2、使用 Timer_t Tim
大整数的加减法（C++）
qq_41281545的博客
04-10 3743
题目引用：http://116.56.140.75:8000/JudgeOnline/problem.php?id=17091709: 大整数的加减法时间限制: 1 Sec 内存限制: 64 M题目描述在高精度运算的场合下，通常需要对超级巨大的整数进行运算。现在请你编程帮忙实现大整数的加法和减法运算。输入包含只有加减法的运算表达式。参与运算的整数及其中间结果的取值范围是（-10^10000000...
C++计时器函数
Apaul1111的博客
07-28 1429
1、标准c/c++函数（windows/Linux） 1、clock（）函数，毫秒精度 #include <time.h> clock_t time_begin= clock(); Sleep(1000); clock_t time_end = clock(); std::cout << (time_end - time_begin) << “ms” << std::endl; 1 2 3 4 5 6 2、windows系统提供的API接口 1、微秒精度 Qu
LargeInteger
红色法拉利之路
10-02 593
  import java.math.BigInteger;/**   * 超大整数加减乘除：   * 题目要求：如果系统要使用超大整数（超过long的范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数的加法运算   * @author Jason Huang   *   */ public class LargeIntege
LARGE_INTEGER 大整数
Windows内核学习笔记
07-08 1039
一、LARGE_INTEGER(large大 integer整数) 这里解释前面碰到的LARGE_INTEGER结构。与可能的误解不同，64位数据并非要在64位操作系统下才能使用。在VC中，64位数据的类型为__int64。定义写法如下： __int64 file_offset; //文件偏移 上面之所以定义的变量名为file_offset，是因为文件中的偏移量是一种常见的要使用64位数据的情况。同时，文件的大小也是如此（回忆上一小节中定义的文件大小）。32位数据无符号整型只能表示到4GB。而众所周
LARGE_INTEGER 数据结构使用，测量Sleep精度
dijkstar的专栏
04-07 4324
测试程序： #include #include LARGE_INTEGER a = {0}; void main() { //赋值 //a.QuadPart = 0x1020304050607080; a.QuadPart = 0x9999; //输出1、2、3 printf("1. Hi= 0x%04x, LO= 0x%04x\n", a.HighPart, a.LowPa
c/c++时间操作函数总结
justkong的博客
07-27 2200
一、时区相关概念 地球自西往东转动，东边比西边先看到太阳，所以东边的时间比西边的时间早。将地球经度按照24个时区进行划分，每个时区相隔的经度为15度。以英国伦敦（格林尼治天文台旧址）为中时区（零时区），向东有11个时区，向西也有11个时区，太平洋白令海峡所在经度为12区，东西各占一半。0时区向东每隔一个时区时间快1小时，向西每隔一个时区时间慢1小时。在12区中间，左边刚好比右边日期大1天。 U...
大整数加减法C/C++源代码
03-23
文件提供了大整数加减法源代码，已在visual C++2.0上编译通过
大整数加减法C++源代码
12-15
c++大整数加减法的源代码，使用链表完成，希望对大家有用啊
C++实现的大整数加减乘除
02-28
C++实现的大整数加减乘法，已经测试了，并且在oj平台上测试通过
C++编写大整数加减法，乘法
06-12
C语言编写 visual C++ 下调试通过
使用C++中string实现任意长度的正小数、整数之间加减法方法实例
08-30
主要介绍了利用C++中string函数实现任意长度的正小数、整数之间加减法方法实例，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面跟着小编一起来学习学习吧。
布线问题-分支限界法
庚午步雲
08-20 8180
布线问题就是在 M×N 的方格阵列中，指定一个起点 a、一个终点 b，要求找到起点到终点的最短布线方案（最短路径）。 搜索从起点 a 开始，到目标点 b 结束。约束条件：有边相连且未成布线。 搜过过程：从起点 a 开始，将其作为一个扩展结点，沿 a 的上、下、左、右 4 个方向的相邻结点扩展。判断约束条件是否成立，如果成立，则放入活结点表中，并将这些方格标记为 1。接着从活结点表中取出队首结点
用双向链表实现超长整数加减法
06-12
好的，我可以为您解答这个问题。 首先，我们需要定义一个双向链表结构体，包含三个成员变量：前驱节点指针、后继节点指针和当前节点的值。代码如下： ```c++ struct Node { Node *prev, *next; int val; }; ``` 接下来，我们可以定义一个类来实现超长整数的加减法。在这个类中，我们需要定义两个双向链表，分别存储两个超长整数的每一位。加法操作需要从链表的尾部开始遍历，同时在遍历的过程中需要考虑进位。减法操作需要先比较两个超长整数的大小，然后从链表的尾部开始遍历，同时在遍历的过程中需要考虑借位。 下面是一个示例代码，可以实现超长整数的加减法： ```c++ class LongInt { public: LongInt() { head1 = new Node; head2 = new Node; tail1 = head1; tail2 = head2; head1->prev = NULL; head2->prev = NULL; head1->next = tail1; head2->next = tail2; tail1->prev = head1; tail2->prev = head2; tail1->next = NULL; tail2->next = NULL; } void add(int x) { Node *node = new Node; node->val = x; node->prev = tail1; node->next = tail1->next; tail1->next = node; tail1 = node; } void sub(int x) { Node *node = new Node; node->val = x; node->prev = tail2; node->next = tail2->next; tail2->next = node; tail2 = node; } LongInt operator+(const LongInt& other) const { LongInt res; Node *p = tail1->prev; Node *q = other.tail1->prev; int carry = 0; while (p != head1->prev || q != other.head1->prev || carry != 0) { int x = (p != head1->prev ? p->val : 0); int y = (q != other.head1->prev ? q->val : 0); int sum = x + y + carry; carry = sum / 10; sum %= 10; res.add(sum); if (p != head1->prev) p = p->prev; if (q != other.head1->prev) q = q->prev; } return res; } LongInt operator-(const LongInt& other) const { LongInt res; Node *p = tail1->prev; Node *q = other.tail1->prev; bool borrow = false; if (compare(other) < 0) { borrow = true; std::swap(p, q); } while (p != head1->prev || q != other.head1->prev) { int x = (p != head1->prev ? p->val : 0); int y = (q != other.head1->prev ? q->val : 0); if (borrow) x--; if (x < y) { x += 10; borrow = true; } else { borrow = false; } int diff = x - y; res.sub(diff); if (p != head1->prev) p = p->prev; if (q != other.head1->prev) q = q->prev; } return res; } int compare(const LongInt& other) const { Node *p = tail1->prev; Node *q = other.tail1->prev; while (p != head1->prev || q != other.head1->prev) { int x = (p != head1->prev ? p->val : 0); int y = (q != other.head1->prev ? q->val : 0); if (x > y) { return 1; } else if (x < y) { return -1; } if (p != head1->prev) p = p->prev; if (q != other.head1->prev) q = q->prev; } return 0; } private: Node *head1, *head2, *tail1, *tail2; }; ``` 使用示例： ```c++ LongInt a, b; a.add(9); a.add(9); a.add(9); b.add(1); b.add(0); LongInt c = a + b; LongInt d = a - b; ``` 在这个示例中，我们创建了两个超长整数 a 和 b，然后分别添加了三个数字和两个数字。接着，我们通过重载运算符实现了加法和减法操作，并将结果存储在变量 c 和 d 中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值