较完备的大浮点数的加减乘法

最新推荐文章于 2022-10-19 20:56:06 发布
最新推荐文章于 2022-10-19 20:56:06 发布
阅读量665 收藏 1
点赞数
分类专栏： 杂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Ema1997/article/details/52753005
版权
本文介绍了如何使用自定义头文件‘BigDec.h’实现大浮点数的加、减、乘法操作。通过具体的代码实例，详细阐述了大数值计算的逻辑和方法，为处理高精度浮点数运算提供了参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

头文件名称：”BigDec.h”

#ifndef BIGDEC_H_INCLUDED
#define BIGDEC_H_INCLUDED
#include <string>

using namespace std;

class BigDec
{
private:
    vector<int> inte;//存储小数点前的数位，越往左，索引越大
    vector<int> doub;//存储小数点后数位，越往右，索引越大
    //索引例：3210.0123
    int flag;//如果flag为-1则为负，1则为正，0则代表这个数为0

    int AddTrans(BigDec &a1, BigDec &a2)//全变为同符号数加同符号数形式
    {
        if (a1.flag == 1 && a2.flag == -1) {
            a2.flag = 1;
            Minus (a1, a2);
            a2.flag = -1;//不能忘记减完之后再换回来
            return 0;
        }
        if (a1.flag == -1 && a2.flag == 1) {
            a1.flag = 1;
            Minus (a2, a1);
            a1.flag = -1;
            return 0;
        }
        if (a1.flag == 0) {
            inte = a2.inte;
            doub = a2.doub;
            flag = a2.flag;
            return 0;
        }
        if (a2.flag == 0) {
            inte = a1.inte;
            doub = a1.doub;
            flag = a1.flag;
            return 0;
        }
        return 1;
    }

    int MinusTrans(BigDec &a1, BigDec &a2)//全变为正数或0减正数或0
    {
        //全变为正数-正数形式
        if (a1.flag == 1 && a2.flag == -1) {
            a2.flag = 1;
            Add (a1, a2);
            a2.flag = -1;
            return 0;
        }
        if (a1.flag == -1 && a2.flag == 1) {
            a2.flag = -1;
            Add (a1, a2);
            a2.flag = 1;
            return 0;
        }
        if (a1.flag == -1 && a2.flag == -1) {
            a1.flag = 1;
            a2.flag = 1;
            Minus (a2, a1);
            a1.flag = -1;
            a2.flag = -1;
            return 0;
        }
        return 1;
    }

    void DelZero()
    {
        //删除前导0
        int l1 = inte.size();
        for (int i = l1 - 1; i >= 0; i--) {
            if (inte[i] == 0) inte.pop_back();
            else break;
        }
        l1 = inte.size();
        if (l1 == 0) inte.push_back (0);

        //删除末尾的0
        int l2 = doub.size();
        for (int i = l2 - 1; i >= 0; i--) {
            if (doub[i] == 0) doub.pop_back();
            else break;
        }
    }

public:
    void operator = (BigDec c)
    {
        inte = c.inte;
        doub = c.doub;
        flag = c.flag;
    }

    int Compare (BigDec c)//返回1则比c小
    {
        if (flag == 1) {
            if (c.flag == -1 || c.flag == 0) return -1;
            int l1 = inte.size();
            int l2 = c.inte.size();
            if (l1 < l2) return 1;
            if (l1 > l2) return -1;
            for (int i = l1 - 1; i >= 0; i--) {
                if (inte[i] < c.inte[i]) return 1;
                if (inte[i] > c.inte[i]) return -1;
            }
            l1 = doub.size();
            l2 = c.doub.size();
            int l = min (l1, l2);
            for (int i = 0; i < l; i++) {
                if (doub[i] < c.doub[i]) return 1;
                if (doub[i] > c.doub[i]) return -1;
            }
            if (l1 != l) return -1;
            if (l2 != l) return 1;
        }
        if (flag == 0) {
            if (c.flag == 1) return 1;
            if (c.flag == -1) return -1;
        }
        if (flag == -1) {
            if (c.flag == 1 || c.flag == 0) return 1;
            int l1 = inte.size();
            int l2 = c.inte.size();
            if (l1 < l2) return -1;
            if (l1 > l2) return 1;
            for (int i = l1 - 1; i >= 0; i--) {
                if (inte[i] < c.inte[i]) return -1;
                if (inte[i] > c.inte[i]) return 1;
            }
            l1 = doub.size();
            l2 = c.doub.size();
            int l = min (l1, l2);
            for (int i = 0; i < l; i++) {
                if (doub[i] < c.doub[i]) return -1;
                if (doub[i] > c.doub[i]) return 1;
            }
            if (l1 != l) return 1;
            if (l2 != l) return -1;
        }
        return 0;
    }

    void CreatDec(string s)//创建大浮点数类型
    {
        if (s[0] == '-') flag = -1;
        else if (s[0] == '0') flag = 0;
        else flag = 1;
        int l = s.size();
        int dot = l;//小数点的位置
        for (int i = 0; i < l; i++) {
            if (s[i] == '.') {
                dot = i;
                break;
            }
        }
         for (int i = dot - 1; i >= 0; i--) {
            if (s[i] == '-') break;
            inte.push_back(s[i] - '0');
         }
         for (int i = dot + 1; i < l; i++) {
            doub.push_back(s[i] - '0');
         }
        DelZero ();
    }

    void PrintDec()//打印大浮点数
    {
        int l1 = inte.size();
        int l2 = doub.size();
        if (flag == -1) printf ("-");
        for (int i = l1 - 1; i >= 0; i--) {
            printf ("%d", inte[i]);
        }
        if (l2 != 0) {//由于可能是整数，所以要判断一下
            printf (".");
            for (int i = 0; i < l2; i++) {
                printf ("%d", doub[i]);
            }
        }
        printf ("\n");
    }

    void Add(BigDec &a1, BigDec &a2)//a1+a2
    {
        if (AddTrans (a1, a2) == 0) return;
        if (a1.flag == 1 && a2.flag == 1) flag = 1;
        else flag = -1;
        int li1 = a1.inte.size();
        int ld1 = a1.doub.size();
        int li2 = a2.inte.size();
        int ld2 = a2.doub.size();

        //加法运算的主函数段
        //将长的那部分直接赋值给c
        string s;
        if (ld1 < ld2) {
            for (int i = ld2 - 1; i >= ld1; i--) {
                s += a2.doub[i] + '0';
            }
        }
        if (ld1 > ld2) {
            for (int i = ld1 - 1; i >= ld2; i--) {
                s += a1.doub[i] + '0';
            }
        }

        int ld = min (ld1, ld2);
        int flag1 = 0;//如果flag1 == 1，则说明要进位
        for (int i = ld - 1; i >= 0; i--) {
            int temp = a1.doub[i] + a2.doub[i] + flag1;
            if (temp / 10 != 0) flag1 = 1;
            else flag1 = 0;
            s += temp % 10 + '0';
        }
        int l = s.length();
        for (int i = l - 1; i >= 0; i--) {
            doub.push_back(s[i] - '0');
        }
        s.clear();

        int li = min (li1, li2);
        for (int i = 0; i < li; i++) {
            int temp = a1.inte[i] + a2.inte[i] + flag1;
            if (temp / 10 != 0) flag1 = 1;
            else flag1 = 0;
            inte.push_back(temp % 10);
        }
        if (li1 != li) {
            for (int i = li; i < li1; i++) {
                int temp = a1.inte[i] + flag1;
                if (temp / 10 != 0) flag1 = 1;
                else flag1 = 0;
                inte.push_back(temp % 10);
            }
        }
        if (li2 != li) {
            for (int i = li; i < li2; i++) {
                int temp = a2.inte[i] + flag1;
                if (temp / 10 != 0) flag1 = 1;
                else flag1 = 0;
                inte.push_back(temp % 10);
            }
        }
        if (flag1) inte.push_back(1);

        DelZero ();
    }

    void Minus(BigDec &a1, BigDec &a2)//a1-a2
    {
        if (MinusTrans (a1, a2) == 0) return;
        //处理0
        if (a1.flag == 0 && a2.flag == 0) {
            inte = a1.inte;
            doub = a1.doub;
            flag = a1.flag;
            return;
        }
        if (a1.flag == 0) {
            inte = a2.inte;
            doub = a2.doub;
            flag = -1;
            return;
        }
        if (a2.flag == 0) {
            inte = a1.inte;
            doub = a1.doub;
            flag = -1;
            return;
        }

        int Test = a1.Compare(a2);
        if (Test == 0) {
            inte.push_back(0);
            flag = 0;
            return;
        }
        if (Test == -1) {//如果a1比a2大
            flag = 1;
            int li1 = a1.inte.size();
            int li2 = a2.inte.size();
            int ld1 = a1.doub.size();
            int ld2 = a2.doub.size();
            int ldmax = max (ld1, ld2);
            if (ld1 < ldmax) {
                for (int i = 0; i < ldmax - ld1; i++) {
                    a1.doub.push_back (0);
                }
            }
            if (ld2 < ldmax) {
                for (int i = 0; i < ldmax - ld2; i++) {
                    a2.doub.push_back (0);
                }
            }

            int flag1 = 0;//如果flag1为1则说明要借位
            //处理小数位
            string s;
            for (int i = ldmax - 1; i >= 0; i--) {
                int temp = a1.doub[i] - a2.doub[i] - flag1;
                if (temp < 0) {
                    temp += 10;
                    flag1 = 1;
                } else {
                    flag1 = 0;
                }
                s += temp + '0';
            }
            int l = s.length();
            for (int i = l - 1; i >= 0; i--) {
                doub.push_back(s[i] - '0');
            }
            s.clear();
            if (ld1 < ldmax) {
                for (int i = 0; i < ldmax - ld1; i++) {
                    a1.doub.pop_back();
                }
            }

            //处理整数位
            int li = min (li1, li2);
            for (int i = 0; i < li; i++) {
                int temp = a1.inte[i] - a2.inte[i] - flag1;
                if (temp < 0) {
                    temp += 10;
                    flag1 = 1;
                } else {
                    flag1 = 0;
                }
                inte.push_back(temp);
            }
            if (li1 != li) {
                for (int i = li; i < li1; i++) {
                    int temp = a1.inte[i] - flag1;
                if (temp < 0) {
                    temp += 10;
                    flag1 = 1;
                } else {
                    flag1 = 0;
                }
                inte.push_back(temp);
                }
            }
            if (inte.size() == 0) inte.push_back(0);
            DelZero();
            return;
        }
        if (Test == 1) {
            Minus (a2, a1);
            flag = -1;
            return;
        }
    }

    void Multi(BigDec a1, BigDec a2)//a1*a2
    {
        flag = a1.flag * a2.flag;
        int dot = a1.doub.size() + a2.doub.size();
        string s, s1, s2;
        int li1 = a1.inte.size();
        int li2 = a2.inte.size();
        int ld1 = a1.doub.size();
        int ld2 = a2.doub.size();
        for (int i = ld1 - 1; i >= 0; i--) {
            s1 += a1.doub[i] + '0';
        }
        for (int i = 0; i < li1; i++) {
            s1 += a1.inte[i] + '0';
        }
        for (int i = ld2 - 1; i >= 0; i--) {
            s2 += a2.doub[i] + '0';
        }
        for (int i = 0; i < li2; i++) {
            s2 += a2.inte[i] + '0';
        }
        int l1 = s1.length();
        int l2 = s2.length();
        int l = l1 + l2 + 1;
        while (l--) {
            s += '0';
        }

        for (int i = 0; i < l1; i++) {
            for (int j = 0; j < l2; j++) {
                int temp = (s1[i] - '0') * (s2[j] - '0') + s[i + j] - '0';
                s[i + j] = temp % 10 + '0';
                s[i + j + 1] += temp / 10;
            }
        }
        l = s.length();
        for (int i = dot - 1; i >= 0; i--) {
            doub.push_back(s[i] - '0');
        }
        for (int i = dot; i < l; i++) {
            inte.push_back(s[i] - '0');
        }
        if (inte.size() == 0) inte.push_back(0);
        DelZero ();
    }
};

#endif // BIGDEC_H_INCLUDED

具体应用实例：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include "BigDec.h"

using namespace std;

int main()
{
    while(1) {
        string s1, s2;
        cout  << "请输入第一个数：" << endl;
        cin >> s1;
        cout << "请输入第二个数：" << endl;
        cin >> s2;
        BigDec a1, a2;
        a1.CreatDec (s1);
        a2.CreatDec (s2);
        while (1) {
            cout << "求和输入1，求差输入2，求积输入3，重新输入数输入4，结束程序输入0"<< endl;
            int flag = 0;
            int dir;
            cin >> dir;
            switch (dir) {
                case 0:return 0;
                case 1:{
                    BigDec c1;
                    c1.Add (a1, a2);
                    c1.PrintDec ();
                    break;
                }
                case 2:{
                    BigDec c2;
                    c2.Minus (a1, a2);
                    c2.PrintDec ();
                    break;
                }
                case 3:{
                    BigDec c3;
                    c3.Multi (a1, a2);
                    c3.PrintDec ();
                    break;
                }
                case 4:{
                    flag = 1;
                    break;
                }
                default:{
                    cout << "输入错误，请重新输入"  << endl;
                }
            }
            if (flag) break;
        }
    }
    return 0;
}
零知识证明；电路，编码，多项式是什么；零知识验证流程
ZJQ的博客
07-07 180
零知识证明；电路，编码，多项式是什么；零知识验证流程
【数理逻辑三】命题逻辑及形式系统【上】
smilejiasmile的博客
06-14 2261
命题逻辑及形式系统 一、数理逻辑简介 逻辑学是一门研究推理的科学、同时也是研究语义关系的科学。最早由古希腊学者亚里士多德创立。其中最具有代表性的就是亚里士多德的三段论学说。只要符合三段论的推理就是正确的。一个三段论就是一个包括有大前提、小前提和结论三个部分的论证。 例： ① 凡是人都会死（大前提） ② 苏格拉底是人（小前提） ③ 所以：苏格拉底会死（结论） 在这一阶段，逻辑学还是以自然语言来表述，但其中最大的问题就是自然语言的模糊性损害其准确和权威。直到逻辑学开始使用用数学的方法研究关于推理、证明等问
[大整数运算]--浮点数加法
圣托里尼的日落啊~的博客
06-02 452
题目来源：codeup连接 题目描述 求2个浮点数相加的和 题目中输入输出中出现浮点数都有如下的形式： P1P2…Pi.Q1Q2…Qj 对于整数部分，P1P2…Pi是一个非负整数 对于小数部分，Qj不等于0 输入 对于每组案例，第1行是测试数据的组数n，每组测试数据占2行，分别是两个加数。 每组测试数据之间有一个空行，每行数据不超过100个字符 输出 每组案例是n行，每组测试数据有一行输出是相应的...
大（长）浮点数加法
weixin_42701161的博客
01-29 670
（C++代码）转载链接：https://blog.youkuaiyun.com/qq_36721800/article/details/104649796 牛客链接：https://www.nowcoder.com/practice/ddec753f446e4ba4944e35378ba635c8?tpId=61&tqId=29551&tPage=3&ru=/kaoyan/retest/1002&qru=/ta/pku-kaoyan/question-ranking java代码 pub
浮点数的大数加法模板
lmlimiao的专栏
10-16 505
// 浮点数大数加法 #include #include #include #include using namespace std; string b,b2,e,e2,b1,e1; string add(string a,string b) // 大数的加法 { reverse(a.begin(),a.end()); reverse(b.begin(),b.end())
BigDecimal(大浮点数)
weixin_30920853的博客
04-24 91
因为这个单词，和他的四则运算方法总是记不住，所以写入博客，在没有印象的时候再看看自己的博客。 BigDecimal的加减乘除不和double float 一样，他需要使用方法来进行加减乘除。 加法：add 减法：subtract 乘法：multiply 除法：divide 转载于:https://www.cnblogs.com/sucker/p/10762399.html...
Java大浮点数
u011714517的博客
01-30 777
BigDecimal 文章参考自https://blog.youkuaiyun.com/GD_ONE/article/details/103951501和百度百科 精度问题 BigDecimal舍入模式 ROUND_DOWN 向零舍入。 即1.55 变为 1.5 , -1.55 变为-1.5 ROUND_UP 向远离0的方向舍入 即 1.55 变为 1.6 , -1.55 变为-1.6 ROUND_CEI...
计算器 实现加减乘除混合运算
06-11
在Android开发中，创建一个能够实现加减乘除混合运算的计算器是一项常见的任务。这个计算器不仅需要处理基本的数学运算，还要能优雅地处理复杂的表达式。以下将详细讲解实现这个功能所需的关键知识点。 首先，我们...
用Android studio写的一个四则运算计算器源码以及开发说明
02-08
开发者可能使用栈数据结构来实现运算符优先级的处理，遵循"先乘除后加减"的原则。 5. **运算符处理**：对于加法、减法、乘法和除法，开发者需要实现对应的数学运算方法。这些方法通常在自定义的Calculator类中定义...
用MFC制作简单计算器
08-26
在本文中，我们将深入探讨如何使用Microsoft Foundation Class (MFC) 库来创建一个简单的计算器应用，该应用能够执行基本的四则运算：加法、减法、乘法和除法。MFC 是 Microsoft 提供的一个 C++ 类库，它为 Windows ...
大数运算（整数、浮点）
12-22
这个C#库中包含两个类，ComputeStringFloat和ComputeStringInt，分别是整数运算和浮点运算，已经重载了+-*/四则运算，以及>,=,<=,==,!=比较运算，支持直接将字符串赋值给这个类，如果需要源代码，请前往https://download.youkuaiyun.com/download/qq_25784203/10869688
牛客网-浮点数加法【大数运算系列】
csyifanZhang的博客
04-23 456
求2个浮点数相加的和 题目中输入输出中出现浮点数都有如下的形式： P1P2...Pi.Q1Q2...Qj 对于整数部分，P1P2...Pi是一个非负整数 对于小数部分，Qj不等于0
【算法·算法随笔】（大整数运算）大浮点数问题的总结
亿维数组's博客
10-19 382
算法笔记》中，对于大整数的运算，给出了最基础的几个算法模板，包括大整数的结构体、输出、与字符串的转换，以及四则预算（不包含高精度与高精度的乘除）。但是在codeup训练当中，又出现了两种经典问题，第一是对大浮点数的处理，第二是对于大整数的进制转换问题。定义一个布尔类型的flag，记录目前存储的状态（是正在处理整数部分还是处理小数部分呢？从后往前，先处理小数，从小数的低位开始相加，思路与普通的大整数相加思路差不多,然后再加整数部分就行了。
大浮点数加减乘除【算法笔记】
qq_41048982的博客
11-10 275
import java.math.BigDecimal; public class BigDecimalDemo { static final int location=10; /** * @paramargs * 这个类提供精确的浮点数运算 */ public static BigDecimal add(double value1,double value2){ BigDecimal b1=new BigDecimal(Double.toString(value1)); Bi.
【字符串】大数的乘法（包括浮点数）
Zk
04-22 6549
一.大数乘法 我们知道，要运算两个数的乘法，c、c++语言里有专门的运算符*。但是当两个数超过一定的范围时，用普通的运算符会产生溢出，并不能得到正确的结果。如何进行运算呢？       首先，要想保存一个大数，用正常的整形或浮点类型是不够的。所以我们可以采用字符串的形式对大数进行保存，然后编写算法，模拟乘法运算过程即可。 1.第一个问题：两个数字运算结果至多用多少位的字符串保存呢？ 两个4
BigDecimal 大浮点数的简单操作
XiaoBoYes的博客
07-15 139
BigDecimal 大浮点数的简单操作
大数计算（进阶） 支持大浮点数的任意精度加减乘除
qq_15689151的博客
04-07 1982
上一篇实现了大数加法，乘除法都是简单的复用加法，这样做时间复杂度高，精度低。进阶：1.乘法模拟竖式计算方法 核心思路是num1[i]*num2[j]的结果一定对应乘积中的[i+j]位，并且考虑对[i+j+1]位的进位。    这样的时间复杂度为O(m*n) 而简单的复用加法的时间复杂度为 (q/p)*(n+m)其中q，p为大数的实际值，n，m为大数的位数，这样当p很小的时候，时间复杂度会很大。进一...
128 带有小数的浮点数 大数乘法
小人物的草稿本
11-06 1777
/* 28、两个数相乘，小数点后位数没有限制，请写一个高精度算法 */ /* HDU 1254 推箱子BFS广搜 两个位置：箱子的位置和人的位置,每次搜索箱子的位置， 判断人是否能到达箱子后面的那点！ */ /* HDOJ 1871 贪心排序 题意 几间宾馆，入住学生，每个组在一间，输入若干组的人数，能否住宿？ 排序即可 */ #include #include #include #i
java基础——大整数和大浮点数
linz的博客
08-24 828
Java中的整型int和浮点型float、double，他们存放数据的范围有限，当需要计算更大的数据是可以考虑用java.math.BigInteger和java.math.BigDecimal BigInteger【任意精度的整数运算】 import java.util.*; import java.math.*; public class Main{ public s...
C++浮点数加减运算代码实现详解
在进行浮点数运算时，首先需要对两个数的指数部分进行对齐，即将指数较小的数通过右移尾数的方式使其指数与指数较大的数相同，然后对尾数进行加减运算。最后，对运算结果进行规格化处理，以确保其符合IEEE 754标准的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值