(C++)大数计算问题

最新推荐文章于 2024-07-18 23:31:00 发布
最新推荐文章于 2024-07-18 23:31:00 发布
阅读量1.1k 收藏 25
点赞数 23
分类专栏： C++课设实验报告 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61219098/article/details/135494036
版权

文章目录

一、实验目的、内容

大数是超过整数表示范围的整数，针对正整数运算，定义一个大数类，并编写两个大数类对象的加法和减法函数。

二、实验程序设计及结构

1.需求分析

类

bigu，内含p(unsigned char*)、n(size_t)数据成员及构造函数、析构函数等成员函数。

变量

bigu类型数据a和b，用于测试数据。

函数

主函数、运算符重载函数及bigu类的成员函数。

2.设计结构或流程图

  1. 进行a和b的输入。（调用构造函数及istream& operator>>(istream& c, bigu& x)）
    1. 从输入的第一个数字字符开始，定义unsigned short临时数组（看作256进制数）。
    2. 每输入一个数字字符，每个数组元素乘10。
    3. 遍历临时数组，将超过255的元素执行进位操作；若数组长度不够，重新定义数组并拷贝。
    4. 不断输入直到遇到非数字字符为止。
    5. 将临时数组的数据拷贝进unsigned char数组并存储。
  2. 进行a和b的加法并输出。（调用bigu operator+(const bigu& x, const bigu& y)和ostream& operator<<(ostream& c, const bigu& x)）
    1. 加法运算
      1. 根据整数运算进位的性质，和的元素个数为max(x.n,y.n)或max(x.n,y.n)+1，故定义max(x.n,y.n)+1长度的临时数组。
      2. 按x.n和y.n的大小分类讨论。
      3. 将临时数组初始化为x和y各位元素之和。
      4. 遍历临时数组，对值超过255的执行进位操作。
      5. 将临时数组的数据拷贝进unsigned char数组并存储。
    2. 输出
      1. 定义临时数组。
      2. 从最高位开始，将超过9的数据进行十进制展开。
      3. 每次加新数之前将原来的所有元素乘256并对超过9的数进行进位。
      4. 输出并释放临时数组。
  3. 比较a与b的大小，作差后输出。（调用bool operator>(const bigu& x, const bigu& y)、bigu operator-(const bigu& x, const bigu& y)和ostream& operator<<(ostream& c, const bigu& x)）
    1. 大于运算
      1. 若两者元素个数不同，直接返回结果。
      2. 逐位比较，直到两者不相等为止。
    2. 减法运算（与加法类似）

三、设计过程

#include <iostream>
using namespace std;
class bigu
{
public:
    unsigned char *p;                                  // 指向正整数数组
    size_t n;                                          // 数组长度
    bigu() { *(p = new unsigned char[n = 1]) = '\0'; } // 默认构造函数：初始化为0
    // 带参数构造（无符号整型）
    bigu(unsigned long long x)
    {
        unsigned char a[8], *q(a), *t(q);
        *q = x;
        while (x >>= 8)
            *++q = x; // 逐字节读取
        *(p = new unsigned char[n = ++q - t]) = *t;
        while (++t < q)
            *++p = *t;
        ++(p -= n);
    }
    // 为了防止浅拷贝的问题，重写拷贝构造函数
    bigu(const bigu &x)
    {
        delete[] p; // 防止内存泄漏
        const unsigned char *q(x.p);
        *(p = new unsigned char[n = x.n]) = *q;
        while (--n)
            *++p = *++q;
        ++(p -= n = x.n);
    }
    ~bigu() { delete[] p; } // 析构函数
    // 为了加快效率、避免拷贝的有参构造函数
    bigu(unsigned char *a, size_t b)
    {
        p = a;
        n = b;
    }
};
// 重载关系运算符
bool operator>(const bigu &x, const bigu &y)
{
    if (x.n > y.n)
        return true;
    if (y.n > x.n)
        return false;
    const unsigned char *p(x.p + x.n), *q(y.p + y.n);
    do
        if (*--p > *--q)
            return true;
        else if (*p < *q)
            return false;
    while (p > x.p);
    return false;
}
// 重载加法运算符
bigu operator+(const bigu &x, const bigu &y)
{
    const unsigned char *p(x.p), *q(y.p); // 读取数据
    // 考虑新数组大小将会是x,y中较大的那个或是较大的加1
    // 故分类讨论
    if (y.n > x.n)
    {
        size_t n(x.n);
        unsigned short *a(new unsigned short[y.n + 1]), *t(a + y.n); // 定义临时数组
        // 向临时数组输入数据
        *a = *p + *q;
        while (--n)
            *++a = *++p + *++q;
        while (++a < t)
            *a = *++q;
        // 处理首位
        if (*(a -= (n = y.n)--) > 255)
        {
            *(a + 1) += *a / 256;
            *a %= 256;
        }
        // 处理头尾之间
        while (--n)
            if (*++a > 255)
            {
                *(a + 1) += *a / 256;
                *a %= 256;
            }
        // 处理最高位
        if (*++a > 255) // 超过了unsigned char表示的范围
        {
            // 拷贝、释放并返回
            unsigned char *u(new unsigned char[y.n + 1] + (n = y.n));
            *u = *a / 256;
            *a %= 256;
            do
                *--u = *--t;
            while (--n);
            delete[] t;
            return bigu(u, y.n + 1);
        }
        // 未超过unsigned char表示的范围
        unsigned char *u(new unsigned char[n = y.n] + y.n);
        *--u = *a;
        while (--n)
            *--u = *--a;
        delete[] a;
        return bigu(u, y.n);
    }
    // 此时x的位数大于等于y的位数
    // 操作过程同理
    if (x.n == 1)
        return bigu(*p + *q);
    size_t n(y.n);
    unsigned short *a(new unsigned short[x.n + 1]), *t(a + x.n);
    *a = *p + *q;
    while (--n)
        *++a = *++p + *++q;
    while (++a < t)
        *a = *++p;
    if (*(a -= (n = x.n)--) > 255)
    {
        *(a + 1) += *a / 256;
        *a %= 256;
    }
    while (--n)
        if (*++a > 255)
        {
            *(a + 1) += *a / 256;
            *a %= 256;
        }
    if (*++a > 255)
    {
        unsigned char *u(new unsigned char[x.n + 1] + (n = x.n));
        *u = *a / 256;
        *a %= 256;
        do
            *--u = *--t;
        while (--n);
        delete[] t;
        return bigu(u, x.n + 1);
    }
    unsigned char *u(new unsigned char[n = x.n] + x.n);
    *--u = *a;
    while (--n)
        *--u = *--a;
    delete[] a;
    return bigu(u, x.n);
}
// 重载减法运算符
// 默认x>=y
bigu operator-(const bigu &x, const bigu &y)
{
    if (x.n == 1) // 由于y<=x，只需要1字节内存空间
    {
        unsigned char *a(new unsigned char[1]);
        *a = *x.p - *y.p;
        return bigu(a, 1);
    }
    const unsigned char *p(x.p), *q(y.p);             // 读取
    short *a(new short[x.n]), *t(a), *r(a + x.n - 1); // 定义临时数组
    *t = *p - *q;
    size_t n(y.n);
    while (--n)
        *++t = short(*++p) - short(*++q); // 由于p,q为无符号指针，需要进行强制类型转换
    while (++t <= r)
        *t = *++p;
    if (*(t = a) < 0)
    {
        --*(t + 1);
        *t += 256;
    } // 对首位进行退位操作
    while (++t < r)
        if (*t < 0)
        {
            *(t + 1) += *t / 256 - 1;
            (*t %= 256) += 256;
        } // 对其余各位进行退位操作
    ++t;
    while (!*--t)
        ; // 找到首个大于0的高位
    // 拷贝数据进新的合适大小的数组
    unsigned char *u(new unsigned char[n = ++t - a] + n);
    do
        *--u = *--t;
    while (t > a);
    delete[] a; // 防止内存泄漏
    return bigu(u, n);
}
// 重载右移运算符，用以输入
istream &operator>>(istream &c, bigu &x)
{
    delete[] x.p; // 释放原来的数组，防止内存泄漏
    char s;       // 由于不知道大数的上限，采用逐字节读取方式
    do
        c.get(s);
    while (s == ' ' || s == '\n' || s == '\t'); // 排除空格、水平制表符和换行
    if (s < '0' || s > '9')                     // 如果输入的不是数字，按0处理
    {
        *(x.p = new unsigned char[x.n = 1]) = 0;
        return c;
    }
    unsigned short *a(new unsigned short[x.n = 10]), *b(a), *p; // 定义临时数组，用范围比unsigned char稍大的类型进行临时存储，a指向最低位，b指向目前的最高位
    *a = s - '0';                                               // 存储第一位
    c.get(s);
    while (s >= '0' && s <= '9')
    {
        (*(p = a) *= 10) += s - '0'; // 加上新数并乘10(位权)
        while (++p <= b)
            *p *= 10;       // 每一位乘10
        if (*(p = a) > 255) // 最低位超过了unsigned char的范围
            if (p == b)     // 只有1位的情况
            {
                *++b = *p / 256; // 改变尾指针
                *p %= 256;
                goto F; // 直接进行下一位的读取
            }
            else
            {
                *(p + 1) += *p / 256;
                *p %= 256;
            }
        else if (p == b)
            goto F;     // 只有1位而且不需要处理
        while (++p < b) // 处理头尾之间的数据
            if (*p > 255)
            {
                *(p + 1) += *p / 256;
                *p %= 256;
            }
        if (*p > 255)           // 最高位需要进位
            if (++b - a == x.n) // 事先的上限不够用，重新申请更大的存储空间并拷贝
            {
                unsigned short *u(a), *v(new unsigned short[x.n += 10]);
                *(p = v) = *a;
                while (++a < b)
                    *++p = *a;
                delete[] u;
                a = v;
                *(b = p + 1) = *p / 256;
                *p %= 256;
            }
            else // 够用，直接处理
            {
                *b = *p / 256;
                *p %= 256;
            }
    F:
        c.get(s);
    }
    // 将处理结果拷贝进unsigned char数组并释放临时数组
    unsigned char *q(x.p = new unsigned char[x.n = ++b - (p = a)]);
    *q = *p;
    while (++p < b)
        *++q = *p;
    delete[] a;
    return c;
}
// 重载左移运算符，用以输出
ostream &operator<<(ostream &c, const bigu &x)
{
    size_t m(10);                                           // 先假定一个上限
    unsigned short *t(new unsigned short[m]), *a(t), *b(t); // 用范围比unsigned char稍大的类型进行临时存储，a指向最低位，b指向目前的最高位
    const unsigned char *q(x.p + x.n);                      // 用于读取数据的指针
    if ((*t = *--q) > 9)
        do
        {
            *++b = *t / 10;
            *t %= 10;
        } while (*++t > 9); // 如果最高位大于等于10
    while (--q >= x.p)
    {
        (*(t = a) *= 256) += *q; // 新位加上原来的乘上位权(256)
        while (++t <= b)
            *t *= 256; // 各高位乘位权(256)
        t = a;
        while (t != b) // 处理头尾之间的位，使它们都小于10
        {
            *(t + 1) += *t / 10;
            *t %= 10;
            ++t;
        }
        if (*t > 9) // 如果最高位需要处理
        {
            if (false)
            F:
            { // 预先的上限不够用，重新申请更大的存储空间
                unsigned short *u(t = new unsigned short[m += 30]), *v(a);
                *u = *a;
                while (++a < b)
                    *++u = *a;
                delete[] v;
                a = t;
                t = b = u;
            }
                // 处理最高位
                do
                {
                    if (++b - a == m)
                        goto F;
                    *b = *t / 10;
                    *t++ %= 10;
                } while (*b > 9);
        }
    }
    c << *b; // 输出最高位
    while (--b >= a)
        c << *b; // 输出其余各位
    delete[] a;  // 释放临时数组
    return c;
}
// 主函数
// 用以测试数据
int main()
{
    bigu a, b;
    cout << "请输入大数a:\n";
    cin >> a;
    cout << "请输入大数b:\n";
    cin >> b;
    cout << "a+b=" << a + b << endl;
    if (a > b)
        cout << "a-b=" << a - b << endl;
    else
        cout << "b-a=" << b - a << endl;
    system("pause");
    return 0;
}

四、测试分析

第一组

在这里插入图片描述

第二组

在这里插入图片描述

实验中出现的bug及解决方案

实验中出现的bug：忽略了大数的进位、退位问题。

解决方案：定义更大的临时数据数组并逐位处理。

五、设计的特点和结果

设计采用的数据结构为数组。为了表示大数，把unsigned char数组看作256进制的数，而不是十进制数，节约了内存空间，并利用动态内存分配技术，解决了大数问题。在实验过程中，我原本是打算逐个扩充数组（每次数组长度加1），后来发现运行的效率很低，就采用了和标准库类型vector类似的内存分配方法，每次多扩充29位，解决了效率低的问题。

zsc_118
关注
  • 23
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++处理大数问题/高精度问题,看这就够了
北北北
07-28 1万+
将带你了解 1.大数加法 2.大数减法 3.辨识负数的大数加减法 4.大数乘法 5.大数除法
计数问题（/C++）
caf2000的博客
07-30 5512
 计数器 (count) 【问题描述】     一本书的页数为N，页码从1开始编起，请你求出全部页码中，用了多少个0，1，2，…，9。其中—个页码不含多余的0，如N＝1234时第5页不是0005，只是5。 【输入】  一个正整数N(N≤109)，表示总的页码。 【输出】  共十行：第k行为数字k-1的个数。 【样例】  count.in    count.out  11  
C++之BigNumber
weixin_50749380的博客
05-17 641
class BigNumber { public: //val为正整数或者0 string val; //初始化 BigNumber() :val("0") {} BigNumber(string s) :val(s) {} //加法操作 + BigNumber operator +(const BigNumber& x) { BigNumber bn; bn.val = add(this->val, x.
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++类实现大整数
MuQYun的博客
12-02 1238
在计算机科学和工程中，整数类型有一个上限，称为其最大值或最大表示值，这限制了数字的大小范围。在一些应用中，需要处理比这个上限更大的整数，这时就需要使用大整数类。 大整数类允许处理比计算机所提供的整数类型更大的整数，通常是以字符串形式存储，可以进行算术运算、比较和转换等操作。这在密码学、数值计算、物理仿真、金融等领域中非常有用。 比如在密码学中，RSA加密算法就需要对非常大的整数进行加密和解密。在数值计算中，需要进行高精度计算，避免舍入误差，保证计算结果的准确性。在物理仿真中，需要模拟非常大或非常小的量。
C++之高精度算发
千里之行，始于足下
03-05 259
前言:由于计算机运算是有模运算,数据范围的表示有一定限制,如整型int(C++中int 与long相同)表达范围是(-2^31~2^31-1),unsigned long(无符号整数)是(0~2^32-1),都约为几十亿.如果采用实数型,则能保存最大的double只能提供15~16位的有效数字,即只能精确表达数百万亿的数.因此,在计算位数超过十几位的数时,不能采用现有类型,只能自己编程计算.高精度...
c++做计算器遇到问题，求大佬指教
shxy1978的博客
05-29 424
//这样做输出总是0， #include<bits/stdc++.h> using namespace std; int jia(double a,double b) { double t; t=a+b; return t; } int jian(double a,double b) { double t; t=a-b; return t; } int cheng(double a,double b) { double t; t=...
C++实现大数相乘的算法
08-25
但对于学习和理解大数计算的基本原理，这是一个很好的起点。在实际应用中，可以考虑使用如GMP（GNU Multiple Precision Arithmetic Library）这样的库来处理大数运算，以获得更好的性能和兼容性。
C++大数计算简单实例测试
09-07
本项目“C++大数计算简单实例测试”提供了一个基本的解决方案，用于进行大数的算术运算，如加法、减法、乘法等。以下将详细介绍该实例所涵盖的C++知识点。 1. **自定义数据结构**： 在C++中，由于没有内置的大数...
c++实现大数计算问题
12-09
以下是一些关于C++实现大数计算的关键知识点： 1. **自定义大数类（BigInt）**：通常，我们会创建一个类（如BigInt）来存储和操作大数。这个类通常会包含一个整数数组来保存每一位数字，并提供相应的运算符重载（如...
C++大数问题
05-13
在编程领域，尤其是在C++这样的...综上所述，大数问题在C++编程中是一个重要的主题，需要理解如何存储和操作大数，以及如何实现大数的加减乘除运算。这通常涉及到自定义数据结构、算法设计和错误处理等多个方面的知识。
D.rar_c++大数除法
07-15
在C++编程中，处理大数（通常超过标准整型或浮点型所能表示的范围）的除法是一项挑战，特别是在需要保持精确性时，如本例中的100位大数除法并保留100位小数。C++标准库并不直接支持这种操作，因此我们需要自定义算法...
c++求两个数或三个数最大值的方法
weixin_64565233的博客
09-01 1万+
c++求两个数或三个数最大值的 方法一： 直接用if语句判断 方法二： 用求两数最大值公式： max(a,b)=(a+b+abs(a+b))/2 此外，求两数最小值公式： min(a,b)=(a+b-abs(a-b))/2 方法三： 利用c++专门求两个数最大值最小值的函数，即algorithm头文件下的max() 注意：①.有人说不用algorithm头文件也能运行出max()，min()，那只是针对个别编译器。 ②.网上还有人说，做牛客网的在线编程题，有道题用到了max()函数，发现了一个小坑，比
C++面向对象程序设计：编写重载函数Max1（或使用函数模板）分别求取两个整数，三个整数，两个双精度，三个双精度数的最大值。
热门推荐
Ac-Buffoon的博客
10-22 2万+
使用C++语言编写重载函数Max1（或使用函数模板）分别求取两个整数，三个整数，两个双精度，三个双精度数的最大值。
基于C++实现的大整数计算
01-13 1643
基于C++实现的大整数计算
面向对象：求最大值
日月光辉的博客
03-28 770
C++：以面向对象的方式求几个数的最大值，程序中包含类的定义，对象的初始化，构造函数和析构函数#include<iostream> using namespace std; class MyClass { private: int value; public: MyClass(int i) //构造函数 { value=i; cout<<"C
万字长文 | 最好的 C++ 模板元编程干货！
青春不老，奋斗不止！
06-26 1017
置顶/星标公众号????，硬核文章第一时间送达！链接 | https://www.cnblogs.com/liangliangh/p/4219879.html所谓元编程就是编写直接生成或操...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 237
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++ 继承篇
最新发布
2301_79201049的博客
07-18 658
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
c++大数计算 a 的 n 次方
06-28
在使用大数计算时，需要注意精度问题和溢出问题。可以使用高精度计算库或自己实现高精度算法来处理这些问题。 因此，想要计算一个数的n次方，可以使用大数计算技术，并将n拆分成多个部分来计算，避免精度和溢出问题...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zsc_118

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

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

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

打赏作者

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

抵扣说明：

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

余额充值