C++ 大整数运算+-*（运算符重载）

已于 2024-06-08 16:54:44 修改
阅读量341 收藏 3
点赞数 3
分类专栏： 数据结构 c++ oj 文章标签： c++
于 2023-06-07 21:21:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aw2371/article/details/131096354
版权

定义大整数，重载*+-，并进行运算。

-00 -0 -002 002 00 0 999999999999999999999999999999999 等情况都有考虑到c1f1a140e4404877a3f19806759df26e.png

#include <iostream>
#include <cstring>
using namespace std;
class CBigInteger
{
private:
    char *p;
public:
    CBigInteger(char *num);
    CBigInteger();
    CBigInteger(const CBigInteger &b);
    ~CBigInteger(){delete []p;}
    CBigInteger operator+(const CBigInteger &r);
    CBigInteger operator-(CBigInteger &r);
    CBigInteger operator*(CBigInteger &r);
    bool operator>=(CBigInteger &r);
    friend istream& operator>>(istream &in,CBigInteger &r);
    friend ostream& operator<<(ostream &out,CBigInteger r); 

};
CBigInteger::CBigInteger(char *num) {
    p = new char[1001];
    strcpy(p,num);
}
CBigInteger::CBigInteger() {
    p = new char[1001];
}
CBigInteger::CBigInteger(const CBigInteger &b) {
    p = new char[1001];
    strcpy(p,b.p);
}

CBigInteger CBigInteger::operator+(const CBigInteger &r) {//正数+正数 或者 负数加负数
    CBigInteger res,temp1(this->p),temp2(r.p);
    char sign='+';
    int len1=strlen(temp1.p),len2=strlen(temp2.p);
    if(*this->p=='-' && *r.p=='-')
    {
        sign='-';
        for(int tt=1;tt<len1;tt++)
            temp1.p[tt-1]=temp1.p[tt];
        temp1.p[len1-1]='\0';
        for(int tt=1;tt<len2;tt++)
            temp2.p[tt-1]=temp2.p[tt];
        temp2.p[len2-1]='\0';
    }
    else if(*this->p!='-' && *r.p=='-')//正+负
    {
        for(int tt=1;tt<len2;tt++)
            temp2.p[tt-1]=temp2.p[tt];
        temp2.p[len2-1]='\0';
        return temp1-temp2;
    }
    else if(*this->p=='-' && *r.p!='-')//负+正
    {
        for(int tt=1;tt<len1;tt++)
            temp1.p[tt-1]=temp1.p[tt];
        temp1.p[len1-1]='\0';
        return temp2-temp1;
    }
    len1=strlen(temp1.p),len2=strlen(temp2.p);
    int len3=max(len1,len2),flag=0;//进位标志
    for(int tt=0;tt<=len3+1;tt++)
        res.p[tt]='\0';
    int i,j,k;
    for(i=len1-1,j=len2-1,k=len3-1;i>=0&&j>=0;i--,j--,k--)
    {
        res.p[k]='0'+(temp1.p[i]+temp2.p[j]-2*'0')%10+flag;
        flag=(temp1.p[i]+temp2.p[j]-2*'0')/10;
        if(k==0 && flag!=0)//进位溢出，数组内每一个数都往后面挪移位
        {
            for(int tt=len3;tt>=0;tt--)
                res.p[tt+1]=res.p[tt];
            res.p[0]='0'+(temp1.p[i]+temp2.p[j]-2*'0')/10;
            len3++;
        }
    }
    while (i>=0)
    {
        res.p[k]='0'+(temp1.p[i]-'0'+flag)%10;
        flag=(temp1.p[i]-'0'+flag)/10;
        if(k==0 && flag!=0)
        {
            for(int tt=len3;tt>0;tt--)
                res.p[tt+1]=res.p[tt];
            res.p[0]='0'+(temp1.p[i]-'0'+flag)/10;
            len3++;
        }
        i--,k--;
    }
    while (j>=0)
    {
        res.p[k]='0'+(temp2.p[j]-'0'+flag)%10;
        flag=(temp2.p[j]-'0'+flag)/10;
        if(k==0 && flag!=0)
        {
            for(int tt=len3;tt>0;tt--)
                res.p[tt+1]=res.p[tt];
            res.p[0]='0'+(temp2.p[j]-'0'+flag)/10;
        }
        j--,k--;
    }
    if(sign=='-')
    {
        for(int tt=len3-1;tt>=0;tt--)
            res.p[tt+1] = res.p[tt];
        res.p[0]=sign;
    }
    return res;
}

CBigInteger CBigInteger::operator-(CBigInteger &r) {
    CBigInteger res,temp1(this->p),temp2(r.p);
    char sign='+';
    int len1=strlen(temp1.p),len2=strlen(temp2.p),len3=0;
    if(*this->p!='-' && *r.p!='-')//正数-正数
    {
        if(temp1>=temp2)
            sign='+';
        else
            sign='-';
        len1=strlen(temp1.p),len2=strlen(temp2.p);
        len3=max(len1,len2);
        int flag=0;//借位标志
        for(int tt=0;tt<=len3;tt++)
            res.p[tt]='\0';
        int i,j,k;
        for(i=len1-1,j=len2-1,k=len3-1;i>=0&&j>=0;i--,j--,k--)
        {
            if(sign=='+')
            {
                if(temp1.p[i]-temp2.p[j]-flag>=0)
                    res.p[k]=temp1.p[i]-temp2.p[j]+'0'-flag;
                else
                {
                    res.p[k]=temp1.p[i]+10-temp2.p[j]+'0'-flag;
                    flag=1;
                }
            }
            else if(sign=='-')
            {
                if(temp2.p[j]-temp1.p[i]-flag>=0)
                    res.p[k]=temp2.p[j]-temp1.p[i]+'0'-flag;
                else
                {
                    res.p[k]=temp2.p[j]+10-temp1.p[i]+'0'-flag;
                    flag=1;
                }
            }
        }
        while (i>=0)
        {
            if(temp1.p[i]-flag>=0)
                res.p[k]=temp1.p[i]-flag;
            else
            {
                res.p[k]=temp1.p[i]+10-flag;
                flag=1;
            }
            i--,k--;
        }
        while (j>=0)
        {
            if(temp2.p[j]-flag>=0)
                res.p[k]=temp2.p[j]-flag;
            else
            {
                res.p[k]=temp2.p[j]+10-flag;
                flag=1;
            }
            j--,k--;
        }
    }
    else if(*this->p=='-' && *r.p=='-')//负数-负数
    {
        for(int tt=1;tt<len1;tt++)
            temp1.p[tt-1]=temp1.p[tt];
        temp1.p[len1-1]='\0';
        for(int tt=1;tt<len2;tt++)
            temp2.p[tt-1]=temp2.p[tt];
        temp2.p[len2-1]='\0';
        return temp2-temp1;//转成正数-正数
    }
    else if(*this->p!='-' && *r.p=='-')//正数-负数
    {
        for(int tt=1;tt<len2;tt++)
            temp2.p[tt-1]=temp2.p[tt];
        temp2.p[len2-1]='\0';
        return temp1+temp2;//转成正数+正数
    }
    else if(*this->p=='-' && *r.p!='-')//负数-正数
    {
        for(int tt=len2;tt>=0;tt--)
            temp2.p[tt+1]=temp2.p[tt];
        temp2.p[0]='-';
        return temp1+temp2;//转成负数+负数
    }//避免出现了100-99=001这种情况
    while (res.p[0]=='0' && len3!=1)
    {
        for(int ii=0;ii<len3;ii++)
            res.p[ii]=res.p[ii+1];
        len3=strlen(res.p);
    }
    if(sign=='-')
    {
        for(int tt=len3;tt>=0;tt--)
            res.p[tt+1] = res.p[tt];
        res.p[0]=sign;
    }
    return res;
}

CBigInteger CBigInteger::operator*(CBigInteger &r) {
    CBigInteger res,temp1(this->p),temp2(r.p);
    char sign='+';
    int len1=strlen(temp1.p),len2=strlen(temp2.p);

    if(this->p[0]=='0' || r.p[0]=='0')
    {
        res.p[0]='0';
        res.p[1]='\0';
        return res;
    }
    if(*this->p=='-' && *r.p=='-'){//负数*负数
        sign='+';
        for(int tt=1;tt<len1;tt++)
            temp1.p[tt-1]=temp1.p[tt];
        temp1.p[len1-1]='\0';
        for(int tt=1;tt<len2;tt++)
            temp2.p[tt-1]=temp2.p[tt];
        temp2.p[len2-1]='\0';
        len1=strlen(temp1.p),len2=strlen(temp2.p);
    }
    else if(*this->p!='-' && *r.p!='-')//正数*正数
        sign='+';
    else if(*this->p=='-' && *r.p!='-'){ //负数*正数
        sign='-';
        for(int tt=1;tt<len1;tt++)
            temp1.p[tt-1]=temp1.p[tt];
        temp1.p[len1-1]='\0';
        len1=strlen(temp1.p);
    }
    else if(*this->p!='-' && *r.p=='-')//正数*负数
    {
        sign='-';
        for(int tt=1;tt<len2;tt++)
            temp2.p[tt-1]=temp2.p[tt];
        temp2.p[len2-1]='\0';
        len2=strlen(temp2.p);
    }

    int len3=len1+len2;
    for(int tt=0;tt<len3;tt++)
        res.p[tt]='0';
    res.p[len3]='\0';
    CBigInteger array[len2];
    for(int i=len1-1;i>=0;i--) {
        int step = 0;
        for (int j = len2 - 1; j >= 0; j--) {
            int mul = (temp1.p[i] - '0') * (temp2.p[j] - '0');
            int sum = res.p[i + j + 1] - '0' + step + mul % 10;
            res.p[i + j + 1] = sum % 10 + '0';
            step = sum / 10 + mul / 10;
        }
        res.p[i] += step;
    }
    while (res.p[0]=='0' && len3!=1)
    {
        for(int ii=0;ii<len3;ii++)
            res.p[ii]=res.p[ii+1];
        len3=strlen(res.p);
    }
    if(sign=='-')
    {
        for(int tt=len3;tt>=0;tt--)
            res.p[tt+1] = res.p[tt];
        res.p[0]=sign;
    }
    return res;
}

istream &operator>>(istream &in, CBigInteger &r) {
    char temp[1001],*s=new char[1001];
    in>>temp;
    int i=0,a;
    if(temp[0]=='0' && temp[1]!='\0')//判断输入是0还是0001这种
    {
    	for(i=0;temp[i]=='0';i++);
    	if(temp[i]=='\0')
    	strcpy(r.p,"0");else
        strcpy(r.p,temp+i);
	}else 
	if(temp[0]=='-' && temp[1]=='0'&& temp[2]!='\0'){
	s[0]='-';		
		for(i=1;temp[i]=='0';i++);
		if(temp[i]=='\0')
    	strcpy(r.p,"0");else{  		
		for(a=i;a<=strlen(temp);a++)		
		s[a-i+1]=temp[a];
        strcpy(r.p,s);
		}
	}else  if(temp[0]=='-' && temp[1]=='0'&& temp[2]=='\0')
	           strcpy(r.p,"0");
	else strcpy(r.p,temp+i);
    return in;
}

ostream &operator<<(ostream &out, CBigInteger r) {
    if(r.p[0]=='-')
        out<<'('<<r.p<<')';
    else
        out<<r.p;
    return out;
}

bool CBigInteger::operator>=(CBigInteger &r) {//只进行两个正数比较
    if(strlen(p)>strlen(r.p))
        return true;
    if(strlen(p)==strlen(r.p))
    {
        for(int i=0;i<(int)strlen(p);i++)
            if(p[i]>r.p[i])
                return true;
            else if(p[i]<r.p[i])
                return false;
            else
                continue;
        return true;
    }
    return false;
}

int main()
{
    int t;
    char op;
    CBigInteger bigNum1;
    CBigInteger bigNum2;

    cin>>t;
    while (t--)
    {
        cin>>bigNum1>>op>>bigNum2;
        cout<<bigNum1<<" "<<op<<" "<<bigNum2<<" = ";
        if(op=='+')
            cout<<bigNum1+bigNum2<<endl;
        else if(op=='-')
            cout<<bigNum1-bigNum2<<endl;
        else if(op=='*')
            cout<<bigNum1*bigNum2<<endl;
    }
    return 0;
}

草海桐
关注
专栏目录
C++ 实现大整数类运算符重载
wwxy1995的博客
12-09 4207
018:别叫，这个大整数已经很简化了! 查看 提交 统计 提问 总时间限制:  1000ms   内存限制:  65536kB // 在此处补充你的代码 描述 程序填空，输出指定结果 #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdlib&gt; #include &lt;cs...
第十一站:运算符重载operate(+-*/)
qq_48397625的博客
01-20 1050
使用非成员函数重载运算符输入输出运算符重载<<,>>类类型转换成类类型(拷贝)operate(+,-,*,/,=,->,<<,>>)支持使用友元函数(),=,->,[]不支持使用友元函数局限:C/C++的运算符，支持的数据类型，仅限于基本数据类型。
c++ - 大整数加法（重载运算符）
Dexter
06-10 487
利用vector数组存储大整数，并重载运算符
c++语言 运算符重载 使用重载运算符实现类的加法运算
weixin_30561177的博客
11-09 314
//运算符重载 //C++提供了许多内置数据类型,如整形、浮点型、字符型等，也提供了相应的运算符(+,-,>,<等),用于进行数据的数学运算和逻辑运算. //重载运算符的格式如下: //函数类型 operator 运算符号 (参数列表) //{对运算符的重载处理} //使用重载运算符实现类的加法运算 #include <iostream> using ...
面向对象程序设计《类与对象、运算符重载》实现大整数类加法
Andy
03-04 396
减法、乘法、（除法）我后期会导上去 加法，模拟就行，用字符串模拟手工计算。 #include <stdio.h> #include <string.h> #include <algorithm> #include <iostream> #define N 105 #define Int BigInteger using namespace std; ...
C++之运算符的重载实现大数的运算
XD
03-05 2556
前段时间，刚刚看完了刘汝佳的算法入门经典的重载运算符，刚开始不是很懂那是什么鬼，不过，现在学完了C++的运算符重载之后，就感觉So easy！~   实现大数的运算，主要还是字符串的模拟。程序实现大数的运算，说白了，就是我们笔算的过程，而我们需要做的是如何控制程序以我们笔算的过程来运算。   class Operator { public: Operator(){}
实验五、运算符重载 复数+-*/ 大数+-*/
11-29
运算符重载是C++中的一种重要特性，它允许我们为已有的运算符赋予新的含义，使其能适用于自定义的数据类型，如这里的复数类和大数类。 首先，复数类`Complex`被设计用来表示数学中的复数。它包含两个私有成员变量`...
【C++PTA】7-1 运算符重载 分数类 约分
libertye的博客
05-25 3835
请定义一个分数类，拥有两个整数的私有数据成员，分别表示分子和分母（分母永远为正数，符号通过分子表示）。 重载运算符加号"+"，实现两个分数的相加，所得结果必须是最简分数。 输入: 第一行的两个数 分别表示 第一个分数的分子和分母（分母不为0）。 第二行的两个数 分别表示 第二个分数的分子和分母。 输出: 第一个数表示分子，第二个数表示分母（若分数代表的是整数，则不输出分母）。 输入样例: 1 5 2 5 输出样例: 3 5 笑死，写这道题的时候极度烦躁，感觉有很多坑但不想写代码（其实也可能是不会啦）
c++成员运算符重载和友元运算符重载的比较（以++，--运算符为例）
热门推荐
ayangya的博客
12-26 1万+
1、对双目运算符而言，成员运算符重载函数参数列表中含有一个参数，而友元运算符重载函数参数列表含有两个参数；对单目运算符而言，成员运算符重载函数参数列表中没有参数，而友元运算符重载函数参数列表含有一个参数。 2、双目运算符一班可以被重载为友元运算符和成员函数运算符，但是当一个整数与一个复数相加时，必须使用友元函数。 例：友元运算符重载函数实现一个复数与一个整数相加#include<iostream
大数加减乘除---C++运算符重载
请给我一支兰州
03-04 325
#include &lt;iostream&gt; #include &lt;typeinfo&gt; #include &lt;string&gt; #include &lt;vector&gt; #include &lt;iterator&gt; using namespace std; template&lt;typename T&gt; void _swap(T &amp...
实现大整数类的加法
聂泽宇的blog
12-06 1230
首先我们需要定义一个类，它支持传入的是整形，字符串，同时默认参数为0； 其次我们需要重载运算符+，=，重载输出流<<，同时重载输出流时，我们需要用friend定义友元，执行cout<<类的语句； 为了代码的简洁性，我们可以将整形转为字符串来储存。 代码如下 #include <iostream> #include <string> using namespace std; class HugeInteger{ private: string str;
大整数求和（运算符重载）
m0_62788400的博客
04-30 2041
BigInt类表示不超过100位的无符号大整数。试重载>>，<<和+，以支持无符号大整数的输入、输出与求和（假设结果仍是一个不超过100位的无符号大整数）。 重载面向BigInt类对象的运算符： >> << + 裁判测试程序样例： #include <iostream> #include <string> using namespace std; /* 请在这里填写答案 */ int main(){ Big..
PTA---C++之运算符重载---大整数求和（运算符重载） (20分)
zhaoxiy的博客
04-27 9056
PTA----大整数求和（运算符重载） 题目要求 BigInt类表示不超过100位的无符号大整数。试重载>>，<<和+，以支持无符号大整数的输入、输出与求和（假设结果仍是一个不超过100位的无符号大整数）。 重载面向BigInt类对象的运算符： >> << + 裁判测试程序样例： #include <iostream> #inclu...
题目总结:大整数计算（运算符重载）
weixin_42896310的博客
06-14 1901
问题描述: #include #include<string.h> #include using namespace std; //用char型数组存整数的整体思路： /* 1.使用一位作为记录符号位，用’0’表示非负数，用’B’表示负数，初始化时将数组除0下标位置的每一位数据都赋为’A’ （注意：有坑，容易想到用’-1’进行表示，但-1并不是单个 char型数据） 2.传入整型...
【编程题分享】c++ 用类实现 大整数加法与乘法
hehe_xu的博客
09-11 981
用c++中的class类别实现大整数加法与乘法
【C++】C++大数之运算符重载
程序猿周周的博客
08-17 2424
一、实验项目内容Modify the “HugeInteger” Class. The new class should also provide the following overloaded operator capabilities:. Overload the addition operator (+), the subtraction operator (-), the multipli
* 运算符重载 编程题＃4：大整数的加减乘除（Coursera 程序设计与算法；重载：& operator <<, & operator >>, +, -, *, /）
小勇工作室
10-15 1909
编程题＃4：大整数的加减乘除来源: POJ (http://cxsjsxmooc.openjudge.cn/test/D/)注意： 总时间限制: 1000ms 内存限制: 65536kB描述 给出两个正整数以及四则运算操作符（+ - * /），求运算结果。输入 第一行：正整数a，长度不超过100 第二行：四则运算符o，o是“+”，“-”，“*”，“/”中的某一个 第三行：正整数b，长度不超过
正整数大数加减的简单实现
LIJIWEI0611的博客
12-18 305
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string> #include <functional> using namespace std; class BigInt { public: BigInt(std::string str="") :str_int_(str) {} //+ 运算符重载 friend BigInt operator+(const BigInt &a.
C++中的 运算符重载
qq_24472227的博客
04-09 3735
C++的 各种运算符重载：加号、左移、递增、赋值、关系、函数调用
c++高精度++运算符重载
最新发布
03-04
C++中的高精度运算符重载是指对整数进行大数运算时，通过重载运算符来实现对大数的加减乘除等操作。一般情况下，C++内置的整数类型（如int、long等）有一定的位数限制，无法处理超过其表示范围的大数。而通过运算符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

草海桐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值