C++大整数类
用法
把头文件和源代码文件放在同一目录下，然后#include"INT"即可使用。你能对int类的变量进行a=2,a+=3,a%8,a--等等操作，那你就也能对INT进行。INT基于vector，可以实现存储任意大的整数，且利用动态内存机制不会多浪费一点空间
类声明
class INT
{
public:
INT();
template <class T>
INT(T a);
INT(const string & s);
INT(const INT &a);
INT(const char * s);
template <class T>
INT & operator=(const T obj);
INT & operator=(const INT & obj);
friend istream & operator>>(istream & in , INT &a);
friend ostream & operator<<(ostream & out , INT &a);
operator bool();
friend INT operator+(INT a,INT b);
friend INT operator-(INT a,INT b);
friend INT operator*(INT a,INT b);
friend INT operator/(INT a,INT b);
friend INT operator%(INT a,INT b);
template <class T1>
friend INT operator+(T1 a,INT b);
template <class T1>
friend INT operator-(T1 a,INT b);
template <class T1>
friend INT operator*(T1 a,INT b);
template <class T1>
friend INT operator/(T1 a,INT b);
template <class T1>
friend INT operator%(T1 a,INT b);
template <class T2>
friend INT operator+(INT a,T2 b);
template <class T2>
friend INT operator-(INT a,T2 b);
template <class T2>
friend INT operator*(INT a,T2 b);
template <class T2>
friend INT operator/(INT a,T2 b);
template <class T2>
friend INT operator%(INT a,T2 b);
friend bool operator<(INT a,INT b);
friend bool operator>(INT a,INT b);
friend bool operator<=(INT a,INT b);
friend bool operator>=(INT a,INT b);
friend bool operator!=(INT a,INT b);
friend bool operator==(INT a,INT b);
template <class T>
inline INT& operator+=(T b);
template <class T>
inline INT& operator-=(T b);
template <class T>
inline INT& operator*=(T b);
template <class T>
inline INT& operator/=(T b);
template <class T>
inline INT& operator%=(T b);
inline INT& operator++();
inline INT& operator--();
inline INT operator++(int);
inline INT operator--(int);
inline INT operator-();
private:
vector<int> data;
bool sign;
static const long long int BIT=100000000;
static const short int BITb=8;
void print();
void clear();//去除多余的前导0
};
Code
#ifndef __gk_BigInt
#define __gk_BigInt
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
using namespace std;
class INT
{
public:
INT();
template <class T>
INT(T a);
INT(const string & s);
INT(const INT &a);
INT(const char * s);
template <class T>
INT & operator=(const T obj);
INT & operator=(const INT & obj);
friend istream & operator>>(istream & in , INT &a);
friend ostream & operator<<(ostream & out , INT &a);
operator bool();
friend INT operator+(INT a,INT b);
friend INT operator-(INT a,INT b);
friend INT operator*(INT a,INT b);
friend INT operator/(INT a,INT b);
friend INT operator%(INT a,INT b);
template <class T1>
friend INT operator+(T1 a,INT b);
template <class T1>
friend INT operator-(T1 a,INT b);
template <class T1>
friend INT operator*(T1 a,INT b);
template <class T1>
friend INT operator/(T1 a,INT b);
template <class T1>
friend INT operator%(T1 a,INT b);
template <class T2>
friend INT operator+(INT a,T2 b);
template <class T2>
friend INT operator-(INT a,T2 b);
template <class T2>
friend INT operator*(INT a,T2 b);
template <class T2>
friend INT operator/(INT a,T2 b);
template <class T2>
friend INT operator%(INT a,T2 b);
friend bool operator<(INT a,INT b);
friend bool operator>(INT a,INT b);
friend bool operator<=(INT a,INT b);
friend bool operator>=(INT a,INT b);
friend bool operator!=(INT a,INT b);
friend bool operator==(INT a,INT b);
template <class T>
inline INT& operator+=(T b);
template <class T>
inline INT& operator-=(T b);
template <class T>
inline INT& operator*=(T b);
template <class T>
inline INT& operator/=(T b);
template <class T>
inline INT& operator%=(T b);
inline INT& operator++();
inline INT& operator--();
inline INT operator++(int);
inline INT operator--(int);
inline INT operator-();
private:
vector<int> data;
bool sign;
static const long long int BIT=100000000;
static const short int BITb=8;
void print();
void clear();//去除多余的前导0
};
INT Null(0);
INT::INT(const INT &a)
{
data=a.data;
sign=a.sign;
}
INT::INT()
{
data.resize(1);
sign=1;
}
INT::INT(const string & s)
{
int p=0,no=0;
data.resize(1);
sign=1;
for(int i=s.length()-1;i>=0;i--)
{
if(s[i]=='-')
{
sign=0;
continue;
}
no++;
int t=(s[i]-'0');
for(int j=1;j<no;j++)t*=10;
data[p]+=t;
if(no>=BITb)
{
data.push_back(0);
p++;
no=0;
}
}
clear();
}
INT::INT(const char * s)
{
int p=0,no=0;
data.resize(1);
sign=1;
for(int i=strlen(s)-1;i>=0;i--)
{
if(s[i]=='-')
{
sign=0;
continue;
}
no++;
int t=(s[i]-'0');
for(int j=1;j<no;j++)t*=10;
data[p]+=t;
if(no>=BITb)
{
data.push_back(0);
p++;
no=0;
}
}
clear();
}
template <class T>
INT::INT(T a)
{
if(a<0)
{
sign=0;
a=-a;
}
else sign=1;
for(short int p=0;a>0;p++)
{
data.push_back(0);
data[p]=a%BIT;
a/=BIT;
}
clear();
}
ostream & operator<<(ostream & out , INT &a)
{
a.print();
return out;
}
istream & operator>>(istream & in , INT &a)
{
string s;
cin>>s;
a=s;
return in;
}
INT & INT::operator=(const INT & obj)
{
if(this !=&obj)
{
data=obj.data;
sign=obj.sign;
}
return *this;
}
template <class T>
INT & INT::operator=(const T obj)
{
*this=INT(obj);
return *this;
}
INT operator+(INT a,INT b)
{
if(a.sign==0&&b.sign==0)
{
a.sign=b.sign=1;
INT t=a+b;
t.sign=0;
return t;
}
if(a.sign==1&&b.sign==0)
{
b.sign=1;
return a-b;
}
if(a.sign==0&&b.sign==1)
{
a.sign=1;
return b-a;
}
INT ans;
if(a.data.size()<b.data.size())return (b+a);
for(int i=0;i<b.data.size();i++)
{
ans.data.push_back(0);
ans.data[i]+=(a.data[i]+b.data[i])%INT::BIT;
ans.data[i+1]+=(a.data[i]+b.data[i])/INT::BIT;
}
for(int i=b.data.size();i<a.data.size();i++)
{
ans.data.push_back(0);
ans.data[i]+=a.data[i];
}
ans.clear();
return ans;
}
INT operator-(INT a,INT b)
{
if(a.sign==1&&b.sign==0)
{
b.sign=1;
return a+b;
}
if(a.sign==0&&b.sign==1)
{
a.sign=1;
INT t=a+b;
t.sign=0;
return t;
}
if(a.sign==0&&b.sign==0)
{
a.sign=b.sign=1;
return b-a;
}
if(a<b)
{
INT t=b-a;
t.sign=0;
return t;
}
INT ans;
if(a==b)return ans;
for(int i=1;i<a.data.size();i++)ans.data.push_back(0);
for(int i=0;i<a.data.size();i++)
{
ans.data[i]+=a.data[i]-b.data[i];
if(ans.data[i]<0)
{
ans.data[i]+=INT::BIT;
a.data[i+1]--;
}
}
ans.clear();
return ans;
}
INT operator*(INT a,INT b)
{
if(a.sign==1&&b.sign==0)
{
b.sign=1;
INT t=a*b;
t.sign=0;
return t;
}
if(a.sign==0&&b.sign==1)
{
a.sign=1;
INT t=a*b;
t.sign=0;
return t;
}
if(a.sign==0&&b.sign==0)
{
a.sign=b.sign=1;
return a*b;
}
INT ans;
if(a==INT(0)||b==INT(0))return ans;
for(int i=1;i<=a.data.size()+b.data.size();i++)ans.data.push_back(0);
for(int i=0;i<a.data.size();i++)
{
for(int j=0;j<b.data.size();j++)
{
long long t=(long long)a.data[i]*b.data[j];
ans.data[i+j]+=t%INT::BIT;
ans.data[i+j+1]+=t/INT::BIT;
}
}
ans.clear();
return ans;
}
//能跑，但是有极大优化空间，但是懒得优化了，有空再说
INT operator/(INT a,INT b)
{
if(a.sign==0&&b.sign==0)
{
a.sign=b.sign=1;
return a/b;
}
if(a.sign==0&&b.sign==1)
{
a.sign=1;
INT t=a/b;
t.sign=0;
return t;
}
if(a.sign==1&&b.sign==0)
{
b.sign=1;
INT t=a/b;
t.sign=0;
return t;
}
INT ans;
while(a-b>Null)
{
a=a-b;
ans++;
}
return ans;
}
INT operator%(INT a,INT b)
{
if(a.sign==0||b.sign==0)
{
cout<<"error,未定义负数的求模运算"<<endl;
return INT(-1);
}
else
{
while(a-b>Null)
a=a-b;
return a;
}
}
template <class T1>
INT operator+(T1 a,INT b)
{
INT A(a);
return A+b;
}
template <class T1>
INT operator-(T1 a,INT b)
{
INT A(a);
return A-b;
}
template <class T1>
INT operator*(T1 a,INT b)
{
INT A(a);
return A*b;
}
template <class T1>
INT operator/(T1 a,INT b)
{
INT A(a);
return A/b;
}
template <class T1>
INT operator%(T1 a,INT b)
{
INT A(a);
return A%b;
}
template <class T2>
INT operator+(INT a,T2 b)
{
INT B(b);
return a+B;
}
template <class T2>
INT operator-(INT a,T2 b)
{
INT B(b);
return a-B;
}
template <class T2>
INT operator*(INT a,T2 b)
{
INT B(b);
return a*B;
}
template <class T2>
INT operator/(INT a,T2 b)
{
INT B(b);
return a/B;
}
template <class T2>
INT operator%(INT a,T2 b)
{
INT B(b);
return a%B;
}
bool operator<(INT a,INT b)
{
if(a.sign==1&&b.sign==0)return false;
if(a.sign==0&&b.sign==1)return true;
if(a.sign==0&&b.sign==0)
{
a.sign=b.sign=1;
return b<a;
}
if(a.data.size()>b.data.size())return false;
else if(a.data.size()<b.data.size())return true;
if(a.data.size()==1&&a.data[0]==b.data[0]&&a.data[0]==0)return false;
for(int i=a.data.size()-1;i>=0;i--)
{
if(a.data[i]<b.data[i])return true;
if(a.data[i]>b.data[i])return false;
}
return false;
}
bool operator==(INT a,INT b)
{
if(a.sign!=b.sign)
{
if(a.data[0]==b.data[0]&&a.data[0]==0&&a.data.size()==b.data.size()&&a.data.size()==1)
return 1;
else
return 0;
}
if(a.data.size()!=b.data.size())return 0;
for(int i=0;i<a.data.size();i++)
if(a.data[i]!=b.data[i])
return 0;
return 1;
}
bool operator!=(INT a,INT b)
{
return !(a==b);
}
bool operator>(INT a,INT b)
{
return a>=b&&a!=b;
}
bool operator<=(INT a,INT b)
{
return (a<b||a==b);
}
bool operator>=(INT a,INT b)
{
return !(a<b);
}
template <class T>
inline INT& INT::operator+=(T b)
{
*this=*this+INT(b);
return *this;
}
template <class T>
inline INT& INT::operator-=(T b)
{
*this=*this-INT(b);
return *this;
}
template <class T>
inline INT& INT::operator*=(T b)
{
*this=*this*INT(b);
return *this;
}
template <class T>
inline INT& INT::operator/=(T b)
{
*this=*this/INT(b);
return *this;
}
template <class T>
inline INT& INT::operator%=(T b)
{
*this=*this%INT(b);
return *this;
}
inline INT& INT::operator++()
{
*this=*this+INT(1);
return *this;
}
inline INT& INT::operator--()
{
*this=*this-INT(1);
return *this;
}
inline INT INT::operator++(int)
{
INT t= *this;
*this=*this+INT(1);
return t;
}
inline INT INT::operator--(int)
{
INT t=*this;
*this=*this+INT(1);
return t;
}
void INT::print()
{
if(data.size()==1&&data[0]==0||data.size()==0)
{
cout<<0;
return;
}
if(sign==0)cout<<'-';
clear();
cout<<data.back();
for(int i=data.size()-2;i>=0;i--)
{
if(data[i]==0)for(int i=1;i< BIT ;i*=10)cout<<'0';
else
{
int x=0;
for(int t=data[i];t>0;t/=10)x++;
for(int i=1;i<=8-x;i++)cout<<'0';
cout<<data[i];
}
}
}
void INT::clear()
{
while(data.size()>1&&data.back()==0)
data.pop_back();
}
INT::operator bool()
{
if(data.size()==1&&data[0]==0||data.size()==0)
return false;
else
return true;
}
inline INT INT::operator-()
{
INT newthis(*this);
if(newthis.sign==0)newthis.sign=1;
else newthis.sign=0;
return newthis;
}
#endif
测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试
C++大整数类的更多相关文章
- C# 基于大整数类的RSA算法实现（公钥加密私钥解密，私钥加密公钥解密）
但是C#自带的RSA算法类RSACryptoServiceProvider只支持公钥加密私钥解密,即数字证书的使用. 所以参考了一些网上的资料写了一个RSA的算法实现.算法实现是基于网上提供的一个大整 ...
- N！的阶乘附带简单大整数类的输入输出（暂时没有深入的了解）
Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N! 我的思路:就想着大整数类去了,才发现自己还不能很好的掌握,其实这是一个大 ...
- C++高精度计算(大整数类)
Java和Pathon可以不用往下看了 C++的基本数据类型中,范围最大的数据类型不同编译器不同,但是最大的整数范围只有[-2^63-2^63-1](对应8个字节所对应的二进制数大小).但是对于某些需 ...
- 大整数类BIGN的设计与实现 C++高精度模板
首先感谢刘汝佳所著的<算法竞赛入门经典>. 众所周知,C++中储存能力最大的unsigned long long 也是有着一个上限,如果我们想计算非常大的整数时,就不知所措了,所以,我写了 ...
- 用Java的大整数类BigInteger来实现大整数的一些运算
关于BigInteger的构造函数,一般会用到两个: BigInteger(String val); //将指定字符串转换为十进制表示形式: BigInteger(String val,int rad ...
- [ C++ 快速高精度模板 ] [ BigN类 ] 大整数类 高精度 模板 BigInt FFT 快速傅里叶变换
[原创 转载请注明]瞎写的,如果代码有错,或者各位大佬有什么意见建议,望不吝赐教 更新日志: 对于规模较小的整数乘法使用$$O(n^2)$$方法,提高速度 modify()和operator[]的bu ...
- C++ BigInteger 大整数类模板（转）
#include <deque> #include <vector> #include <iostream> #include <string> #in ...
- C++大整数类模板
参考 :http://172.21.85.56/oj/resource/reportdetail?report_id=1678 支持 =.abs().pow().+=.-= *=./=.%=.+.-. ...
- 【Java编程】Java中的大整数计算
在上一篇文章中,我们实现了c语言中的大整数的运算,并且用Miller-Rabin算法实现了对大素数的测试.本来我准备用Java代码实现大整数的运算,查了一下资料发现Java中java.math的Big ...
- Ural 1158. Censored! 有限状态自动机+DP+大整数
Ural1158 看上去很困难的一道题. 原文地址 http://blog.csdn.net/prolightsfxjh/article/details/54729646 题意:给出n个不同的字符,用 ...
随机推荐
- com.alibaba.nacos.api.exception.NacosException
具体异常如下: com.alibaba.nacos.api.exception.NacosException: <html><body><h1>Whitelabel ...
- [CF1641D] Two Arrays
题目描述 Sam changed his school and on the first biology lesson he got a very interesting task about gen ...
- Tensorflow2.0：使用Keras自定义网络实战
tensorflow2.0建议使用tf.keras作为构建神经网络的高级API 接下来我就使用tensorflow实现VGG16去训练数据 背景介绍: 2012年 AlexNet 在 ImageNet ...
- 图片Base64相互转换
一.简介 Base64编码是一种广泛应用于网络传输和数据存储的编码方式.在实际应用中,我们将图片转换为Base64编码,可以大大减少数据量,便于传输和存储.本文将详细介绍图片Base64编码的相互转换 ...
- Java五种设计模式实现奶茶订单生成系统小DEMO
前言 这是大学时候上设计模式这门课写的程序,当时课程任务是要求结合五个设计模式写一个系统,最近偶然翻到,把系统分享一下. 成品预览 主界面 功能介绍 订单管理系统,实现了对订单的增删改查.且实现了 ...
- ElasticSearch之配置
ElasticSearch主要的配置文件,如下: elasticsearch.yml,ElasticSearch的相关参数. jvm.options,JVM的相关参数. log4j2.properti ...
- Python——第四章：内置函数（下）
内置函数的使用方法: locals:函数会以字典的类型返回当前位置的所有局部变量 globals:函数会以字典的类型返回全部局部变量 zip: 可以把多个可迭代内容进行合并 sorted: 排序 fi ...
- 文心一言 VS 讯飞星火 VS chatgpt （31）-- 算法导论5.2 3题
三.利用指示器随机变量来计算掷n 个骰子之和的期望值. 文心一言: 为了计算掷n个骰子之和的期望值,我们需要先了解一个重要的概念:指示器随机变量. 指示器随机变量是一种特殊的随机变量,它只有两个取值: ...
- 华为云AI论文精读会2021第一期：高效语义分割模型Fast-SCNN分享
2020年举办的华为云AI经典论文复现活动,不仅受到了参赛者们一致好评,也产出了许多优质的算法成果.这些论文复现的算法描述.源代码以及算法使用指导文档均已发布到了AI Gallery.为了让开发者更好 ...
- 顶会VLDB‘22论文解读：CAE-ENSEMBLE算法
摘要:针对时间序列离群点检测问题,提出了基于CNN-AutoEncoder和集成学习的CAE-ENSEMBLE深度神经网络算法,并通过大量的实验证明CAE-ENSEMBLE算法能有效提高时间序列离群点 ...