首页 > 编程语言 >C++大整数类

C++大整数类

时间：2023-10-13 20:47:53浏览次数：38  
标签：return INT 整数 C++ template operator data friend

用法

把头文件和源代码文件放在同一目录下，然后#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

测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试测试

标签：return,INT,整数,C++,template,operator,data,friend
From： https://www.cnblogs.com/gongkai/p/17763085.html

相关文章

  • 「闲话随笔」 C++ namespace K8He-Math version -1.0.0 is officially released!
    C++namespaceK8He-Mathversion-1.0.0isofficiallyreleased!写着玩的，不清楚是否有实用价值，看个乐就行，别D.有Bug可以自己调（怎么用感觉比较好看出来.namespaceMATH{ namespaceType{ usingi32=int; usingi64=longlong; usingu32=std::uint32_t;......
  • 5381: C++实验：STL之search
    描述  使用STL中的search函数，判断一个序列是否是另一个序列的子序列。部分代码已经给出，请补充完整，提交时请勿包含已经给出的代码。  C++intmain(){vector<int>vec1,vec2;intn,m,a;cin>>n>>m;while(n--){cin>>a;......
  • 5383: C++实验：STL之multimap
    描述  使用STL中的multimap记录用户的所有电话号码，yuyu想查询用户有多少个电话号码，crq则想查询时输出所有的号码。部分代码已经给出，请补充完整，提交时请勿包含已经给出的代码。 C++intmain(){ multimap<string,string>sm; stringname,phone; intn; cin>>......
  • c++工厂模式和抽象工厂模式的区别是什么
    C++中的工厂模式和抽象工厂模式都是为了实现对象的创建和实例化，但它们在设计和使用方式上有一些区别。工厂模式（FactoryPattern）：工厂模式通过一个工厂类来封装对象的创建逻辑，并将具体对象的创建细节隐藏起来。客户端只需通过工厂类调用相应的方法来获取所需的对象实例。工厂模式......
  • 简单工厂模式--Java实现+C++实现
    问题描述使用简单工厂模式模拟女娲(Nvwa)造人(Person)，如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，如果传入参数R，则返回一个Robot对象。请用程序设计实现上述场景。问题实现用starUML画的相应的类图：然后就是代码实现：Java代码实现在Java里面，Person类相......
  • c++识别不到cout标识符
    问题描述时隔好久，再次使用c++编写程序时，就出现了这个问题，对以前的我来说这就是小case，但是现在就需要查资料了；问题解决文件里面少了这个头文件：#include<iostream>usingnamespacestd;即可解决！......
  • C++不常见语法分析总结
    成员初始化列表用于在构造对象时给类或者结构体成员设置初值。语法为:构造函数():成员1(参数值1),成员2(参数值2)...{}成员初始化列表的作用和优点:可以为非静态数据成员赋予初始值初始化顺序与成员在类中的定义顺序一致效率比在构造函数体内赋值初始化高可以为只......
  • c语言代码练习(无符号整数)29
    #define_CRT_SECURE_NO_WARNINGS1#include<stdio.h>#include<windows.h>intmain(){unsignedinti;for(i=9;i>=0;i--){printf("%u\n",i);Sleep(100);}return0;}死循环，因为无符号整数，没有负数......
  • C++ - 异常处理
    C++ 异常处理异常是程序在执行期间产生的问题。C++异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。异常提供了一种转移程序控制权的方式。C++异常处理涉及到三个关键字：try、catch、throw。throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字......
  • [c++_1]C++ 子类初始化父类成员
    我们知道，构造方法是用来初始化类对象的。如果在类中没有显式地声明构造函数，那么编译器会自动创建一个默认的构造函数；并且这个默认的构造函数仅仅在没有显式地声明构造函数的情况下才会被创建。构造函数与父类的其它成员(成员变量和成员方法)不同，它不能被子类继承。因此，在创建子类......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99