[高精度]高精度的封装

最新推荐文章于 2024-07-25 09:47:19 发布
最新推荐文章于 2024-07-25 09:47:19 发布
阅读量580 收藏 1
点赞数 1
分类专栏： 高精度 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Minecraftwzy/article/details/119426090
版权

这是我最近学到的一个高精度封装,把高精度运用 c l a s s class class类封装成一个变量 I n t Int Int。

#include<bits/stdc++.h>
using namespace std;
class DividedByZeroException {};
class Int {
   private:
       vector<char> digits;
       bool sign;
       void trim();
   public:
       Int(int);
       Int(string&) ;
       Int();
       Int(const Int&);
       Int operator=(const Int& op2);
       Int abs() const;
       Int pow(int a);
       friend Int operator+=(Int&, const Int&);
       friend Int operator-=(Int&, const Int&);
       friend Int operator*=(Int&, const Int&);
       friend Int operator/=(Int&, const Int&) throw(DividedByZeroException);
       friend Int operator%=(Int&, const Int&) throw(DividedByZeroException);
       friend Int operator+(const Int&, const Int&);
       friend Int operator-(const Int&, const Int&);
       friend Int operator*(const Int&, const Int&);
       friend Int operator/(const Int&, const Int&) throw(DividedByZeroException);
       friend Int operator%(const Int&, const Int&) throw(DividedByZeroException);
       friend Int operator-(const Int&);
       friend Int operator++(Int&);
       friend Int operator++(Int&, int);
       friend Int operator--(Int&);
       friend Int operator--(Int&, int);
       friend bool operator>(const Int&, const Int&);
       friend bool operator<(const Int&, const Int&);
       friend bool operator==(const Int&, const Int&);
       friend bool operator!=(const Int&, const Int&);
       friend bool operator>=(const Int&, const Int&);
       friend bool operator<=(const Int&, const Int&);
       friend ostream& operator<<(ostream&, const Int&);
       friend istream& operator>>(istream&, Int&);
   public:
       static const Int ZERO;
       static const Int ONE;
       static const Int TEN;
};
const Int Int::ZERO = Int(0);
const Int Int::ONE = Int(1);
const Int Int::TEN = Int(10);
Int::Int() {
   sign = true;
}
Int::Int(int val) {
   if (val >= 0) {
       sign = true;
   }
   else {
       sign = false;
       val *= (-1);
   }
   do {
       digits.push_back((char)(val % 10));
       val /= 10;
   } while (val != 0);
}
Int::Int(string& def) {
   sign = true;
   for (string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++) {
       char ch = (*iter);
       if (iter == def.rend() - 1) {
           if (ch == '+') {
               break;
           }
           if (ch == '-') {
               sign = false;
               break;
           }
       }
       digits.push_back((char)((*iter) - '0'));
   }
   trim();
}
void Int::trim() {
   vector<char>::reverse_iterator iter = digits.rbegin();
   while (!digits.empty() && (*iter) == 0) {
       digits.pop_back();
       iter = digits.rbegin();
   }
   if (digits.size() == 0) {
       sign = true;
       digits.push_back(0);
   }
}
Int::Int(const Int& op2) {
   sign = op2.sign;
   digits = op2.digits;
}
Int Int::operator=(const Int& op2) {
   digits = op2.digits;
   sign = op2.sign;
   return (*this);
}
Int Int::abs() const {
   if (sign) {
       return *this;
   }
   else {
       return -(*this);
   }
}
Int Int::pow(int a) {
   Int res(1);
   for (int i = 0; i < a; i++) {
       res *= (*this);
   }
   return res;
}
Int operator+=(Int& op1, const Int& op2) {
   if (op1.sign == op2.sign) {
       vector<char>::iterator iter1;
       vector<char>::const_iterator iter2;
       iter1 = op1.digits.begin();
       iter2 = op2.digits.begin();
       char to_add = 0;
       while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
           (*iter1) = (*iter1) + (*iter2) + to_add;
           to_add = ((*iter1) > 9);
           (*iter1) = (*iter1) % 10;
           iter1++;
           iter2++;
       }
       while (iter1 != op1.digits.end()) {
           (*iter1) = (*iter1) + to_add;
           to_add = ((*iter1) > 9);
           (*iter1) %= 10;
           iter1++;
       }
       while (iter2 != op2.digits.end()) {
           char val = (*iter2) + to_add;
           to_add = (val > 9) ;
           val %= 10;
           op1.digits.push_back(val);
           iter2++;
       }
       if (to_add != 0) {
           op1.digits.push_back(to_add);
       }
       return op1;
   }
   else {
       if (op1.sign) {
           return op1 -= (-op2);
       }
       else {
           return op1 = op2 - (-op1);
       }
   }
}
Int operator-=(Int& op1, const Int& op2) {
   if (op1.sign == op2.sign) {
       if (op1.sign) {
           if (op1 < op2) {
               return  op1 = -(op2 - op1);
           }
       }
       else {
           if (-op1 > -op2) {
               return op1 = -((-op1) - (-op2));
           }
           else {
               return op1 = (-op2) - (-op1);
           }
       }
       vector<char>::iterator iter1;
       vector<char>::const_iterator iter2;
       iter1 = op1.digits.begin();
       iter2 = op2.digits.begin();
       char to_substract = 0;
       while (iter1 != op1.digits.end() && iter2 != op2.digits.end()) {
           (*iter1) = (*iter1) - (*iter2) - to_substract;
           to_substract = 0;
           if ((*iter1) < 0) {
               to_substract = 1;
               (*iter1) += 10;
           }
           iter1++;
           iter2++;
       }
       while (iter1 != op1.digits.end()) {
           (*iter1) = (*iter1) - to_substract;
           to_substract = 0;
           if ((*iter1) < 0) {
               to_substract = 1;
               (*iter1) += 10;
           }
           else {
               break;
           }
           iter1++;
       }
       op1.trim();
       return op1;
   }
   else {
       if (op1 > Int::ZERO) {
           return op1 += (-op2);
       }
       else {
           return op1 = -(op2 + (-op1));
       }
   }
}
Int operator*=(Int& op1, const Int& op2) {
   Int result(0);
   if (op1 == Int::ZERO || op2 == Int::ZERO) {
       result = Int::ZERO;
   }
   else {
       vector<char>::const_iterator iter2 = op2.digits.begin();
       while (iter2 != op2.digits.end()) {
           if (*iter2 != 0) {
               deque<char> temp(op1.digits.begin(), op1.digits.end());
               char to_add = 0;
               deque<char>::iterator iter1 = temp.begin();
               while (iter1 != temp.end()) {
                   (*iter1) *= (*iter2);
                   (*iter1) += to_add;
                   to_add = (*iter1) / 10;
                   (*iter1) %= 10;
                   iter1++;
               }
               if (to_add != 0) {
                   temp.push_back(to_add);
               }
               int num_of_zeros = iter2 - op2.digits.begin();
               while (num_of_zeros--) {
                   temp.push_front(0);
               }
               Int temp2;
               temp2.digits.insert(temp2.digits.end(), temp.begin(), temp.end());
               temp2.trim();
               result = result + temp2;
           }
           iter2++;
       }
       result.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
   }
   op1 = result;
   return op1;
}
Int operator/=(Int& op1, const Int& op2) throw(DividedByZeroException) {
   if (op2 == Int::ZERO) {
       throw DividedByZeroException();
   }
   Int t1 = op1.abs(), t2 = op2.abs();
   if (t1 < t2) {
       op1 = Int::ZERO;
       return op1;
   }
   deque<char> temp;
   vector<char>::reverse_iterator iter = t1.digits.rbegin();
   Int temp2(0);
   while (iter != t1.digits.rend()) {
       temp2 = temp2 * Int::TEN + Int((int)(*iter));
       char s = 0;
       while (temp2 >= t2) {
           temp2 = temp2 - t2;
           s = s + 1;
       }
       temp.push_front(s);
       iter++;
   }
   op1.digits.clear();
   op1.digits.insert(op1.digits.end(), temp.begin(), temp.end());
   op1.trim();
   op1.sign = ((op1.sign && op2.sign) || (!op1.sign && !op2.sign));
   return op1;
}
Int operator%=(Int& op1, const Int& op2) throw(DividedByZeroException) {
   return op1 -= ((op1 / op2) * op2);
}
Int operator+(const Int& op1, const Int& op2) {
   Int temp(op1);
   temp += op2;
   return temp;
}
Int operator-(const Int& op1, const Int& op2) {
   Int temp(op1);
   temp -= op2;
   return temp;
}
Int operator*(const Int& op1, const Int& op2) {
   Int temp(op1);
   temp *= op2;
   return temp;

}
Int operator/(const Int& op1, const Int& op2) throw(DividedByZeroException) {
   Int temp(op1);
   temp /= op2;
   return temp;
}
Int operator%(const Int& op1, const Int& op2) throw(DividedByZeroException) {
   Int temp(op1);
   temp %= op2;
   return temp;
}
Int operator-(const Int& op) {
   Int temp = Int(op);
   temp.sign = !temp.sign;
   return temp;
}
Int operator++(Int& op) {
   op += Int::ONE;
   return op;
}
Int operator++(Int& op, int x) {
   Int temp(op);
   ++op;
   return temp;
}
Int operator--(Int& op) {
   op -=  Int::ONE;
   return op;
}
Int operator--(Int& op, int x) {
   Int temp(op);
   --op;
   return temp;
}
bool operator<(const Int& op1, const Int& op2) {
   if (op1.sign != op2.sign) {
       return !op1.sign;
   }
   else {
       if (op1.digits.size() != op2.digits.size())
           return (op1.sign && op1.digits.size() < op2.digits.size())
               || (!op1.sign && op1.digits.size() > op2.digits.size());
       vector<char>::const_reverse_iterator iter1, iter2;
       iter1 = op1.digits.rbegin();
       iter2 = op2.digits.rbegin();
       while (iter1 != op1.digits.rend()) {
           if (op1.sign &&  *iter1 < *iter2) {
               return true;
           }
           if (op1.sign &&  *iter1 > *iter2) {
               return false;
           }
           if (!op1.sign &&  *iter1 > *iter2) {
               return true;
           }
           if (!op1.sign &&  *iter1 < *iter2) {
               return false;
           }
           iter1++;
           iter2++;
       }
       return false;
   }
}
bool operator==(const Int& op1, const Int& op2) {
   if (op1.sign != op2.sign  || op1.digits.size() != op2.digits.size()) {
       return false;
   }
   vector<char>::const_iterator iter1, iter2;
   iter1 = op1.digits.begin();
   iter2 = op2.digits.begin();
   while (iter1 != op1.digits.end()) {
       if (*iter1 != *iter2) {
           return false;
       }
       iter1++;
       iter2++;
   }
   return true;
}
bool operator!=(const Int& op1, const Int& op2) {
   return !(op1 == op2);
}
bool operator>=(const Int& op1, const Int& op2) {
   return (op1 > op2) || (op1 == op2);
}
bool operator<=(const Int& op1, const Int& op2) {
   return (op1 < op2) || (op1 == op2);
}
bool operator>(const Int& op1, const Int& op2) {
   return !(op1 <= op2);
}
ostream& operator<<(ostream& stream, const Int& val) {
   if (!val.sign) {
       stream << "-";
   }
   for (vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++) {
       stream << (char)((*iter) + '0');
   }
   return stream;
}
istream& operator>>(istream& stream, Int& val) {
   string str;
   stream >> str; 
   val = Int(str);
   return stream;
}

对与一般的高精度来说,只需要把高精度数的变量名改成 I n t Int Int,就可以使用了。

注意

这份代码只适用于整数的高精度,小数的话这里用不了哦。

希望这份代码对大家有所帮助。

咸鱼吖
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
封装高精度+,-,*,/
qq_45879198的博客
12-10 1075
文章目录前言一、封装高精的+,-,*,/ 前言 将高精的+,-,*,/都用结构体封装了一遍 提示：以下是本篇文章正文内容，下面案例可供参考 一、封装高精的+,-,*,/ #include <bits/stdc++.h> #define maxn 100 //定义数组 using namespace std; struct Bigint{ //封装结构体 int len,a[maxn];//为了兼顾效率与代码复杂度，用len记录位数，a记录每个数位 Bigint(int x=0){
[c++]封装高精度运算
stary_yan的博客
06-22 991
高精度运算 此文主要给出了高精度运算的实现细节，并将此封装。 #include <string.h> #include <iostream> using namespace std; #define max 1000 /* * This class implements addition, substraction, multiple operation, * which aim to
ACM_高精度算法
小安的博客
07-19 1139
ACM算法 ——高精度算法。
php高精度计算的封装介绍
HoeWang的博客
09-28 442
文章目录概要php浮点数精度计算的坑原因方案php提供的高精度函数库bcBC的主要相关函数可能为缺陷为何需要封装？代码示例关于舍去以及四舍五入如果要BC支持四舍五入关于封装 概要 php浮点数精度计算的坑 $a = 2586; $b = 2585.98; var_dump($a-$b); 期望的结果是：float(0.02) 实际结果： float(0.019999999999982) 原因 小数的二进制表示有时是不可能精确的。 其实道理很简单，十进制系统中能不能准确表示出1/3呢？同样二进制系统也无法
C#实现高精度定时器
dd_zhouqian的专栏
11-26 5983
  转自https://blog.csdn.net/nocky/article/details/6056413 这两天正在准备做一个实时控制的东西，想用C＃。可是昨天日本人展示了一个在LINUX平台下使用C语言控制的单自由度机械臂，我问他们为什么不用WINDOWS，他们说用WINDOWS编程实时性很差，定时很不准，所以用了LINUX，为了兼容性好，服务器也用的是LINUX平台，用于网络控制。可...
高精度温度采集系统设计
哈希马普的博客
12-03 4476
一、模数转换器的选择 工欲善其事必先利其器，要将模拟信号精准转换为数字信号，一个高精度的模数转换器不可或缺，选用合适的模数转换芯片对实现设计应用要求尤为重要。 本设计要求高精度和高稳定性的测量，主要用于温度传感器，预留了多个温度传感器接口，所以相应的ADC的通道数也要预留几个，不然要添加额外的多路开关选择器。 本设计选择ADI公司的AD7794作为模数转换器，片内集成了放大器，程序控制信号放大倍数...
高精度乘法
shallrelow的博客
06-18 733
高精度乘法
Linux下C++跨平台获取高精度时间戳
guotianqing的博客
02-10 2250
简介 C++语言本身及Linux操作系统均提供了时钟相关的函数，可以方便获取时间。 但是，在一些场合下，需要的时间精度不同，又不能通用。 如果依赖于Linux平台，又不能做到跨平台。 所以优化考虑使用C++语言本身提供的函数。 本文介绍使用 std::chrono 命名空间下的函数来获取时间戳。需要 c++11 支持。 关于时间函数的介绍，请参考 Linux c++获取本地毫秒级精确时间 。 获取时间跨度 在测试一段程序的耗时时，经常需要统计时间跨度。 示例代码如下： int countTimeCons
【C++ 高精度计时器】
m0_37545861的博客
09-26 874
【代码】【C++ 高精度计时器】
基本数据类型与高精度数字
csdn1428208016的博客
10-11 3096
基本数据类型
C++高精度模板
03-05
支持（无限）高精度加、减、乘、除、模、大于、小于、大于等于、小于等于、位移、等于、不等于、++、--，cin>>，cout 总之，一切int类型的运算都支持
C++高精度整型对象实现
10-14
C/C++基本类型做算术运算时长度有限，但也...本资源用C++封装了一个高精度整型，完整重载了+-*/%==>>等操作符， 可以直接当整型使用于工程项目，包含了功能测试和性能测试程序，在vs 2019、及ubuntu gcc 均能编译运行。
C++ 高精度封装模板
08-27
此模板为已封装模板，包含 高精度的+，-，*，/，不包含小数 by LAZ
Scripts_高精度_源码
10-02
在编程世界中，高精度计算是一项重要的技能，特别是在处理大整数或需要极高精确度的数学运算时。本文将深入探讨“高精度_源码”这个主题，它涉及到C++编程语言中的算法实现，适用于中小学编程学习者进行基础训练。 ...
高精度模板 c++实现
08-11
高精度c++模板，实测没有问题，可以放心使用，常数一般，代码可移植性和封装性较好
【C++】C++中的find方法介绍
最新发布
qq_35902025的博客
07-25 407
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3433
【代码】背单词工具(C++)
C：图案打印
2401_85010100的博客
07-23 956
空心正方形，空心三角形，X形，沙漏图案打印
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 622
C++ Primer（第5版） 练习 15.28
芯海科技CS1259B ADC用户手册：5通道24位高精度
这篇文档详细介绍了芯海科技（CHIPSEA）的一款高精度24位模数转换器（ADC）——CS1259B。该器件拥有5个通道，适用于需要高精度数据转换的应用场景。 在手册的"版本历史"部分，我们可以看到CS1259B ADC的手册经过了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值