重载“+-*/”实现高精度运算

最新推荐文章于 2024-04-20 16:58:27 发布
最新推荐文章于 2024-04-20 16:58:27 发布
阅读量2.7k 收藏 10
点赞数 5
分类专栏： 基础 文章标签： 高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scanew/article/details/12841373
版权


       在只进行加法和减法时，我们可以压八位来加快速度，当有乘法时，压八位会爆int所以我们压四位。 高精度除法压位比较难写，所以我们不选择压位。在程序的前端声明一个变量P来记录压位的位数，M记录压N位时对应的最小的数，即可使程序更容易调试。

const int M=100000000,
               P=8;
//输出可以这样写
printf("%*d",P,n[i]);


加减，压八位，输出补零

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int M=100000000,
		  P=8; 	//压位

struct bignum 
{
	int n[5000],l; 	//n数组存放每个结构体中的"大数",l记录长度。
	bignum(){l=1,memset(n,0,sizeof(n));}
//-----------------------------------------------
	void init() 	//输入过程
	{
		string s;
		cin>>s;
		int now=0,ct=0,c1=1; //now记录当前是n数组的第几位，ct记录已经读入多少字符了，满八进一，c1是辅助变量，因为我们是倒着读入，所以每次要乘10 
		for(int i=s.length()-1;i>=0;i--)  //从s的长度-1开始 
		{
			n[now]+=(s[i]-'0')*c1;
			c1*=10;
			ct++;
			if(ct==P&&i!=0)  // 如果i=0了就没有必要now++； 
			{
				now++;
				ct=0;
				c1=1;
			}		
		}
		l=now+1;   //l的长度为now+1； 
	}
	void print()
	{
		printf("%d",n[l-1]);
		for(int i=l-2;i>=0;i--)	
		printf("%0*d",P,n[i]);  //补零输出 
		printf("\n");
	}
//-----------------------------------------------
	bignum operator + (bignum x) const 	//重载加号
	{
		bignum t=*this;
		if(x.l>t.l)t.l=x.l;
		for(int i=0;i<t.l;i++)
		{
			t.n[i]+=x.n[i];
			if(t.n[i]>=M)
			{
				t.n[i+1]+=t.n[i]/M;
				t.n[i]%=M;
			}
		}
		return t;			//  注意：将t的值返回 
	} 
//------------------------------------------------
	bool operator < (bignum x) const  	//重载小于号 
	{
		bignum t=*this;
		if(t.l!=x.l)return t.l<x.l;
		for(int i=t.l-1;i>=0;i--)
		{
			if(t.n[i]!=x.n[i]) return t.n[i]<x.n[i];
		}
		return 0;
	}
	bignum operator -(bignum x) const	//重载减号 
	{
		bignum t=*this;
		if(t<x){printf("-");swap(t,x);}
		int jie =0;
		for(int i=0;i<t.l;i++)
		{
			t.n[i]-=x.n[i];
			while(t.n[i]<0)
			{
				t.n[i]+=M;
				jie++;		
			}
			t.n[i+1]-=jie;
			jie=0;
		}
		while(!t.n[t.l-1] && t.l>1)t.l--;  // 相减后有可能出现前面有0的情况，所以t.l--; 
		return t;
	}
//----------------------------------------------
}a,b,c;

int main()
{
	a.init();		//读入字符串a和b 
	b.init();
	
	c=a+b;				
	c.print();

	c=a-b;
	c.print();
	
	c=a*b;
	c.print();
		 
	return 0;
}




加减乘，压四位，输出补零


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int M=10000,
		  P=4; 	//压位

struct bignum 
{
	int n[5000],l; 	//n数组存放每个结构体中的"大数",l记录长度。
	bignum(){l=1,memset(n,0,sizeof(n));}
//-----------------------------------------------
	void init() 	//输入过程
	{
		string s;
		cin>>s;
		int now=0,ct=0,c1=1; //now记录当前是n数组的第几位，ct记录已经读入多少字符了，满八进一，c1是辅助变量，因为我们是倒着读入，所以每次要乘10 
		for(int i=s.length()-1;i>=0;i--)  //从s的长度-1开始 
		{
			n[now]+=(s[i]-'0')*c1;
			c1*=10;
			ct++;
			if(ct==P&&i!=0)  // 如果i=0了就没有必要now++； 
			{
				now++;
				ct=0;
				c1=1;
			}		
		}
		l=now+1;   //l的长度为now+1； 
	}
	void print()
	{
		printf("%d",n[l-1]);
		for(int i=l-2;i>=0;i--)	
		printf("%0*d",P,n[i]);  //补零输出 
		printf("\n");
	}
//-----------------------------------------------
	bignum operator + (bignum x) const 	//重载加号
	{
		bignum t=*this;
		if(x.l>t.l)t.l=x.l;
		for(int i=0;i<t.l;i++)
		{
			t.n[i]+=x.n[i];
			if(t.n[i]>=M)
			{
				t.n[i+1]+=t.n[i]/M;
				t.n[i]%=M;
			}
		}
		return t;			//  注意：将t的值返回 
	} 
//------------------------------------------------
	bool operator < (bignum x) const  	//重载小于号 
	{
		bignum t=*this;
		if(t.l!=x.l)return t.l<x.l;
		for(int i=t.l-1;i>=0;i--)
		{
			if(t.n[i]!=x.n[i]) return t.n[i]<x.n[i];
		}
		return 0;
	}
	bignum operator -(bignum x) const	//重载减号 
	{
		bignum t=*this;
		if(t<x){printf("-");swap(t,x);}
		int jie =0;
		for(int i=0;i<t.l;i++)
		{
			t.n[i]-=x.n[i];
			while(t.n[i]<0)
			{
				t.n[i]+=M;
				jie++;		
			}
			t.n[i+1]-=jie;
			jie=0;
		}
		while(!t.n[t.l-1] && t.l>1)t.l--;  // 相减后有可能出现前面有0的情况，所以t.l--; 
		return t;
	}
//------------------------------------------------
	bignum operator *(bignum x) const //重载乘号 
	{
		bignum t=*this,tep;
		tep.l=t.l+x.l-1;
		for(int i=0;i<t.l;i++)
		for(int j=0;j<x.l;j++)
		{
			tep.n[i+j]+=t.n[i]*x.n[j];
			if(tep.n[i+j]>=M)
			{
				tep.n[i+j+1]+=tep.n[i+j]/M;
				tep.n[i+j]%=M;
			}
		}
		while(tep.n[tep.l])
		{
			tep.n[tep.l+1]+=tep.n[tep.l]/M;
			tep.n[tep.l++]%=M;
		}
		return tep;
	}
//-----------------------------------------
}a,b,c;

int main()
{
	a.init();		//读入字符串a和b 
	b.init();
	
	c=a+b;				
	c.print();

	c=a-b;
	c.print();
	
	c=a*b;
	c.print();
		 
	return 0;
}



加减乘除，不压位


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int M=10,
		  P=1; 	//压位

struct bignum 
{
	int n[5000],l; 	//n数组存放每个结构体中的"大数",l记录长度。
	bignum(){l=1,memset(n,0,sizeof(n));}
//-----------------------------------------------
	void init() 	//输入过程
	{
		string s;
		cin>>s;
		int now=0,ct=0,c1=1; //now记录当前是n数组的第几位，ct记录已经读入多少字符了，满八进一，c1是辅助变量，因为我们是倒着读入，所以每次要乘10 
		for(int i=s.length()-1;i>=0;i--)  //从s的长度-1开始 
		{
			n[now]+=(s[i]-'0')*c1;
			c1*=10;
			ct++;
			if(ct==P&&i!=0)  // 如果i=0了就没有必要now++； 
			{
				now++;
				ct=0;
				c1=1;
			}		
		}
		l=now+1;   //l的长度为now+1； 
	}
	void print()
	{
		printf("%d",n[l-1]);
		for(int i=l-2;i>=0;i--)	
		printf("%0*d",P,n[i]);  //补零输出 
		printf("\n");
	}
//-----------------------------------------------
	bignum operator + (bignum x) const 	//重载加号
	{
		bignum t=*this;
		if(x.l>t.l)t.l=x.l;
		for(int i=0;i<t.l;i++)
		{
			t.n[i]+=x.n[i];
			if(t.n[i]>=M)
			{
				t.n[i+1]+=t.n[i]/M;
				t.n[i]%=M;
			}
		}
		return t;			//  注意：将t的值返回 
	} 
//------------------------------------------------
	bool operator < (bignum x) const  	//重载小于号 
	{
		bignum t=*this;
		if(t.l!=x.l)return t.l<x.l;
		for(int i=t.l-1;i>=0;i--)
		{
			if(t.n[i]!=x.n[i]) return t.n[i]<x.n[i];
		}
		return 0;
	}
	bignum operator -(bignum x) const	//重载减号 
	{
		bignum t=*this;
		if(t<x){printf("-");swap(t,x);}
		int jie =0;
		for(int i=0;i<t.l;i++)
		{
			t.n[i]-=x.n[i];
			while(t.n[i]<0)
			{
				t.n[i]+=M;
				jie++;		
			}
			t.n[i+1]-=jie;
			jie=0;
		}
		while(!t.n[t.l-1] && t.l>1)t.l--;  // 相减后有可能出现前面有0的情况，所以t.l--; 
		return t;
	}
//------------------------------------------------
	bignum operator *(bignum x) const //重载乘号 
	{
		bignum t=*this,tep;
		tep.l=t.l+x.l-1;
		for(int i=0;i<t.l;i++)
		for(int j=0;j<x.l;j++)
		{
			tep.n[i+j]+=t.n[i]*x.n[j];
			if(tep.n[i+j]>=M)
			{
				tep.n[i+j+1]+=tep.n[i+j]/M;
				tep.n[i+j]%=M;
			}
		}
		while(tep.n[tep.l])
		{
			tep.n[tep.l+1]+=tep.n[tep.l]/M;
			tep.n[tep.l++]%=M;
		}
		return tep;
	}
//-----------------------------------------
	void Add(int x){if(x||l)n[l++]=x;}  //除法 
	void Re(){reverse(n,n+l);}          //高精度除以高精度
	bignum operator /(const bignum &x)const
	{
		bignum t=*this,r,y;
		y.l=0,r.l=t.l;
		for(int i=t.l-1;i>=0;--i)
		{
			y.Add(t.n[i]);
			y.Re();
			while(!(y<x))y=y-x,r.n[i]++;
			while(!y.n[y.l-1] && y.l>=1)--y.l;
            y.Re();
		}
		while(!r.n[r.l-1] && r.l>1)--r.l;
		return r;
	}bignum operator /(const int &x)const        //高精度除以单精度
         {
             bignum t=*this,r;
             r.l=t.l;
  	    int tmp=0;
  	    for(int i=t.l-1;i>=0;--i)
   	    {
   		tmp+=t.n[i];
   		if(tmp>=x)
    		r.n[i]+=tmp/x,tmp%=x;
   		tmp*=M;
  	    }
  	    while(!r.n[r.l-1] && r.l>1)--r.l;
  	    return r;
         }
}a,b,c;

int main()
{
	a.init();		//读入字符串a和b 
	b.init();
	
	c=a+b;				
	c.print();

	c=a-b;
	c.print();
	
	c=a*b;
	c.print();
	
	c=a/b;
	c.print();	 
	return 0;
}


最后剽窃一个功能更丰富的- - 


#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int M=10,P=1; 


struct BigNum
{
       int n[5000],l,Y;
       BigNum(){l=1,memset(n,0,sizeof(n));}
       //----------------------------------
       void init()
       {
            string s;
            cin>>s;
            int now=0,ct=0,c1=1;
            for(int i=s.length()-1;i>=0;i--)
            {
             n[now]+=(s[i]-'0')*c1;
             c1*=10;
             ct++;
             if(ct==P&&i!=0)
             {
              now++;
              c1=1;
              ct=0;
             }        
            }
            l=now+1;     
       }
       //-----------------------------------
       void print()
       {
            printf("%d",n[l-1]);
            for(int i=l-2;i>=0;i--)
            printf("%0*d",P,n[i]);
            printf("\n");
       }
       //------------------------------------
       BigNum operator +(BigNum x)const
       {
              BigNum t=*this;
              if(x.l>t.l)t.l=x.l;
              for(int i=0;i<t.l;i++)
              {
               t.n[i]+=x.n[i];
               if(t.n[i]>=M)
               {
                   t.n[i+1]+=t.n[i]/M;
                   t.n[i]%=M;             
               }        
              }
              while(t.n[t.l])
              {
                  t.n[t.l+1]+=t.n[t.l]/M;
                  t.n[t.l++]%=M;               
              }     
              return t;  
       }
       //--------------------------------------
       bool operator < (BigNum x) const
       {
           BigNum t=*this;
           if(t.l!=x.l)return t.l<x.l;
           for(int i=t.l-1;i>=0;i--)
           {
              if(t.n[i]!=x.n[i])return t.n[i]<x.n[i];        
           }
           return 0;       
       }
       BigNum operator -(BigNum x)const
       {
           BigNum t=*this;
           if(t<x){printf("-");swap(t,x);} 
           for(int i=0;i<t.l;i++)
           {
            t.n[i]-=x.n[i];
            if(t.n[i]<0)
            {
                t.n[i]+=M;
                --t.n[i+1];            
            }        
           } 
           while(!t.n[t.l-1]&&t.l>1)t.l--;
           return t;     
       }
       //--------------------------------------------
       BigNum operator * (BigNum x) const
       {
              BigNum c,t=*this;
              c.l=t.l+x.l-1;
              for(int i=0;i<t.l;i++)
              for(int j=0;j<x.l;j++)
              {
                  c.n[i+j]+=t.n[i]*x.n[j];
                  if(c.n[i+j]>=M)
                  {
                      c.n[i+j+1]+=c.n[i+j]/M;
                      c.n[i+j]%=M;               
                  }        
              }
              while(c.n[c.l])
              {
                   c.n[c.l+1]+=c.n[c.l]/M;
                   c.n[c.l++]%=M;               
              }       
              return c;
       }
       BigNum operator * (int x) const
       {
          BigNum t=*this,c;
          c.l=t.l;
          for(int i=0;i<t.l;i++)
          {
              c.n[i]+=t.n[i]*x;
              if(c.n[i]>=M)
              {
                   c.n[i+1]+=c.n[i]/M;
                   c.n[i]%=M;             
              }        
          }       
          while(c.n[c.l])
          {
                 c.n[c.l+1]+=c.n[c.l]/M;
                 c.n[c.l++]%=M;               
          }
          return c;
       }
       //--------------------------------------------
    void Add(int x){if(x||l)n[l++]=x;}
    void Re(){reverse(n,n+l);}
    BigNum operator /(const BigNum &x)const
    {
        BigNum t=*this,r,y;
        y.l=0,r.l=t.l;
        for(int i=t.l-1;i>=0;--i)
        {
            y.Add(t.n[i]);
            y.Re();
            while(!(y<x))y=y-x,r.n[i]++;
            while(!y.n[y.l-1] && y.l>1)--y.l;
            y.Re();
        }
        while(!r.n[r.l-1] && r.l>1)--r.l;
        return r;
    }
    BigNum operator /(const int &x)const
    {
        BigNum t=*this,r;
        r.l=t.l;
        int tmp=0;
        for(int i=t.l-1;i>=0;--i)
        {
            tmp+=t.n[i];
            if(tmp>=x)
                r.n[i]+=tmp/x,tmp%=x;
            tmp*=M;
        }
        while(!r.n[r.l-1] && r.l>1)--r.l;
        return r;
    }
       //---------------------------------------
       
}a,b,c;


int main()
{
    a.init();
    b.init();
    
    c=a+b;
    c.print();
    
    c=a-b;
    c.print();
    
    c=a*b;
    c.print();
    
    c=a/b;
    c.print();
    return 0;        
}


Scanew_2U
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Oracle with as + /*+ materialize*/ 优化
鱼丸丶粗面
06-29 5643
文章目录with aswith as + /* materialize*/ 优化 with as `with as· with as + /* materialize*/ 优化 当 with as 中的表被多次调用时，CBO 优化器会自动决定是否将查询结果写入临时表，进行缓存 /*+ materialize*/ hint 提示，会强制性要求 with as 中的结果转换为 临时表，以此来提高 sql 效率 /*+ inline*/ hint 提示，与上相反，不转换 一般来说，当 with as 表被使
C++操作符重载+、-、*、/、[]、（）、＜＜、＞＞、=、new、delete、&&、||、++、--、+=、强制转换重载
weixin_44190648的博客
12-18 2118
注意：为什么ostream& operator
C++面向对象程序设计 - 运算符重载
最新发布
觉醒法师的专栏
04-20 1288
函数重载就是对一个已有的函数赋予新的含义，使之实现新的功能。因此一个函数名就可以用来代表不同功能的函数，也就是一名多用。运算符也可以重载，即运算符重载（operator overloading）。运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。运算符重载实质上是函数的重载。
基本运算符的运算规则（  +，-，*，/，%，++，--）
Sweeneyzuo的博客
07-19 1万+
运算符： 两原一封：     两个原则：     1)、不同类型的数据做运算时，一定会先转换成较大范围类型后再运算。     2)、byte，short，char这些类型运算时，一定会先转成int类型再运算，结果int类型,两个float类型的值进行计算不会变成double。     封： byte、short、char、int、long有封闭式运算。   算术运算符：+，-，*，/，%，...
Java 正则表达式的用法和实例
热门推荐
Lemon
06-11 15万+
一、概述： 用来描述或者匹配一系列符合某个语句规则的字符串 二、单个符号 1、英文句点”.”符号：匹配单个任意字符。 表达式”t.o“ 可以匹配：tno，t#o，teo等等。不可以匹配：tnno，to，Tno，t正o等。 2、中括号”[]“：只有方括号里面指定的字符才参与匹配，也只能匹配单个字符。 表达式：t[abcd]n 只可以匹配：tan，tbn，tcn，tdn。不可以匹配：th...
C++运算符重载 ++，--，+，-，+=，-=，输出输入运算符
Move on
05-08 5313
https://blog.csdn.net/wenqian1991/article/details/34147997 一、运算符的定义 运算符重载就是运算符的“一符多用”。重载运算符是具有特殊名称的函数：保留字 operator 后接需定义的操作符符号。像任意其他函数一样，重载操作符具有返回类型和形参表，每个操作符用于内置类型都有关联的定义，当内置操作符和类型上的操作存在逻辑对应关系时，操作符...
C++高精度整型对象实现
10-14
C/C++基本类型做算术运算时长度有限，但也...本资源用C++封装了一个高精度整型，完整重载了+-*/%==>>等操作符， 可以直接当整型使用于工程项目，包含了功能测试和性能测试程序，在vs 2019、及ubuntu gcc 均能编译运行。
C++高精度模板（加减乘除模）
02-04
C++竞赛高精度模板 优点：包含四则运算 抛弃传统数组，使用vector 缺点：乘法没有使用FFT算法，复杂度O(N^2) 在某些编辑器上可能无法使用资源中定义的常量，需要手动创建（CE的话可能是这个问题） 没有运算符...
常用的一些自己的库,高精度运算和矩阵乘法
09-16
写高精度运算和矩阵乘法的时候，把常用的都封装在一起，写在一个头文件里方便使用.. 矩阵(matrix) 高精度(longnum) 重载了运算符+,-,*,/ 适用运算： 矩阵相乘 高精度数+高精度数 高精度数+低精度数 高精度数×高...
BigInteger高精度.pdf
11-04
加法运算可以通过将两个高精度整数相加然后进位来实现，减法运算可以通过将一个高精度整数减去另一个高精度整数然后借位来实现，乘法运算可以通过将两个高精度整数相乘然后取模来实现，除法运算可以通过将一个高精度...
C++高精度大数模板
03-11
为了解决这个问题，开发者通常会使用自定义的大数（大整数）实现，即高精度算法。本篇将围绕标题“C++高精度大数模板”展开，详细介绍两种不同的大数模板实现：一种简便，另一种详细。 首先，我们来看“高精度...
高精度重载运算符的C++代码
生息之地
11-03 1985
高精度算法（压位存储）! 有的时候，数字会大到连long long都不能承受的程度。这时，我们可以自己模拟大数的各种运算。 所谓压位存储，就是在高精度数内部采用10000进制（即每四位放到一个数中）进行存储。它与10进制（即一个数位对应一个数）相比速度要快一些。 高精度数内部也可以采用100000000进制，但是这样就不能计算乘除法了。 (1) 定义 编程时这样做——假设hp是高精度类型
“+ - * /”重载
lml58586的专栏
04-25 803
/* * Copyright (c) 2011, 烟台大学计算机学院 * All rights reserved. * 作 者：刘明亮 * 完成日期：2013 年 4 月 24 日 * 版 本 号：v1.0 * 输入描述： * 问题描述:分数类中的对象可以和整型数进行四则运算，且运算符合交换律。 * 例如：CFraction a(1,3),b;int i=2; 可以完成
结构体重载运算符版高精度！
Paperback_Writer的博客
08-09 951
神奇的高精度： 支持高精度加法，大于小于比较，赋值。 用了 *this #include #include #include using namespace std; #define maxn 30 struct bigint { int a[maxn]; bigint() { memset(a,0,sizeof(a)); } bigint& operator
运算符重载的几个例子
renwu
08-03 1万+
1.二元运算符 二元运算符指的是一个运算符有左操作数和右操作数两个对象，比如常见的+、-、*、/等等 1）算术运算符：+、-、*、/、% 2）关系运算符：&lt;=、&gt;=、&lt;、&gt;、!=、== 3）位运算符：^、&amp;、| 4）逻辑运算符：&amp;&amp;、|| 以&gt;=为例： #include &lt;iostream&gt; using namesp...
C++ 重载实例:复数的运算操作
alex1997222的博客
11-18 2649
因为涉及到输入流和输出流的重载,这里先介绍一下输入流和输出流的重载方法: struct Vector { int x; int y; }; 我们要在输出流中直接输出类,比如(1,2),(3,4),那么我们该怎么做呢 这个时候我们要重载输出流: ostream&amp; operator&lt;&lt;(ostream&amp; o, Vector v) { return o &...
正确的重载operator+
h258384667的博客
06-21 2949
为了得到一串链表或者完成两个对象的累加或合并，经常要重载诸如string，date，complex或file等user－define类型的Operator＋。然而，就设计而言，正确地重载operator+面临许多挑战。下面的段落中，我将介绍为用户定义类型选择正确的重载operator+的一般性的策略。     考虑下面的表达式：     int x=4+2;     内建的+运算
高精度加法（重载运算符）
小鬼66
10-05 1199
求A+B（0<=A,B<=10100000）（0<=A,B<=10^{100000}） 高精度加法（重载运算符版），在网上有很多写法，表示不能很清楚的明白其内容，这里给出一份c语言的简单版本，便于学习理解。#include <stdio.h> #include <string.h> #define max(a,b) ((a)>(b)?(a):(b)) struct Data { int a
c++高精度++运算符重载
03-04
C++中的高精度运算符重载是指对整数进行大数运算时，通过重载运算符来实现对大数的加减乘除等操作。一般情况下，C++内置的整数类型（如int、long等）有一定的位数限制，无法处理超过其表示范围的大数。而通过运算符重载，我们可以自定义一个类来表示大数，并对其进行各种运算操作。 以下是一个简单的示例，展示了如何实现C++中的高精度运算符重载： ```cpp #include <iostream> #include <vector> using namespace std; class BigInteger { private: vector<int> digits; // 用vector存储大数的每一位 public: BigInteger() {} BigInteger(int num) { while (num > 0) { digits.push_back(num % 10); num /= 10; } } BigInteger operator+(const BigInteger& other) const { BigInteger result; int carry = 0; int i = 0; while (i < digits.size() || i < other.digits.size() || carry != 0) { int sum = carry; if (i < digits.size()) { sum += digits[i]; } if (i < other.digits.size()) { sum += other.digits[i]; } result.digits.push_back(sum % 10); carry = sum / 10; i++; } return result; } friend ostream& operator<<(ostream& os, const BigInteger& num) { for (int i = num.digits.size() - 1; i >= 0; i--) { os << num.digits[i]; } return os; } }; int main() { BigInteger a(123456789); BigInteger b(987654321); BigInteger c = a + b; cout << "a + b = " << c << endl; return 0; } ``` 在上述示例中，我们定义了一个名为BigInteger的类，用于表示大数。通过重载加法运算符`+`，我们可以实现对两个BigInteger对象的相加操作。同时，我们还重载了输出流运算符`<<`，以便能够直接输出BigInteger对象的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值