大整数类 模板

最新推荐文章于 2023-11-03 10:36:13 发布
最新推荐文章于 2023-11-03 10:36:13 发布
阅读量82 收藏
点赞数
原文链接：http://www.cnblogs.com/kunsoft/p/5312800.html
版权

自己写的大整数模板，已经升级到V2.0

功能：

计算大整数加减乘数取模运算，支持无限位数，支持正负数输入输出及运算，支持判断两个大整数的大小

保障：

1.VC++2013，GCC4.7.3运行测试通过

2.学校OJ加减乘除取模均AC

//BigInt V2.0
//By KunSoft

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cmath>
#include <deque>
#include <iterator>
#include <algorithm>
using namespace std;
typedef long long LLT;

class BigInt
{
public:
	BigInt() :negative(false) {}
	BigInt(const LLT);
	BigInt(const char*);
	BigInt(const string);
	BigInt(const BigInt & x);
	BigInt & operator = (const BigInt &);
	friend istream & operator >> (istream &, BigInt &);
	friend ostream & operator << (ostream &, BigInt);
	BigInt operator + (const BigInt &) const;
	BigInt operator - (const BigInt &) const;
	BigInt operator * (const BigInt &) const;
	BigInt operator / (const LLT &) const;
	LLT operator % (const LLT &) const;
	bool operator > (const BigInt &) const;
	bool operator == (const BigInt &) const;
	bool operator >= (const BigInt &) const;
	friend BigInt abs(const BigInt &);
	BigInt operator - () const;
private:
	deque<int> num;
	bool negative;
};

BigInt::BigInt(const LLT x){
	LLT t = abs(x);
	negative = x >= 0 ? true : false;
	while (t > 0){
		num.push_back(t % 10);
		t = t / 10;
	}
}
BigInt::BigInt(const char* str){
	unsigned i = str[0] == '-' ? 1 : 0;
	this->negative = str[0] == '-' ? true : false;
	for (; i < strlen(str); ++i) num.push_back(str[i] - '0');
}
BigInt::BigInt(const string str){
	unsigned i = str[0] == '-' ? 1 : 0;
	this->negative = str[0] == '-' ? true : false;
	for (; i < str.size(); ++i) num.push_back(str[i] - '0');
}
BigInt::BigInt(const BigInt &x){
	negative = x.negative;
	num = x.num;
}
BigInt & BigInt::operator = (const BigInt &x){
	negative = x.negative;
	num = x.num;
	return (*this);
}
istream & operator >> (istream &is, BigInt & x){
	string str; is >> str;
	x = str;
	return is;
}
ostream & operator << (ostream &os, BigInt x){
	if (x.negative) os << '-';
	for (unsigned i = 0; i != x.num.size(); ++i)
		os << x.num[i];
	return os;
}
bool BigInt::operator > (const BigInt & rhs) const {
	BigInt x = (*this), y = rhs;
	if (!x.negative && y.negative) return true;
	if (x.negative && !y.negative) return false;
	if (x.negative && y.negative) swap(x, y);
	if (x.num.size() > y.num.size()) return true;
	if (x.num.size() < y.num.size()) return false;
	for (unsigned i = 0; i != x.num.size(); ++i) {
		if (x.num[i] > y.num[i]) return true;
		if (x.num[i] < y.num[i]) return false;
	}
	return false;
}
bool BigInt::operator == (const BigInt & rhs) const {
	return negative == rhs.negative && num == rhs.num;
}
bool BigInt::operator >= (const BigInt & rhs) const {
	return *this > rhs || *this == rhs;
}
BigInt abs(const BigInt & rhs){
	BigInt res;
	res.negative = false;
	res.num = rhs.num;
	return res;
}
BigInt BigInt::operator - () const {
	BigInt ret = *this; ret.negative = !ret.negative;
	return ret;
}
BigInt BigInt::operator + (const BigInt & y) const {
	if (!this->negative && y.negative) return *this - abs(y);
	if (this->negative && !y.negative) return y - abs(*this);
	if (this->negative && y.negative) return -(abs(*this) + abs(y));
	BigInt x = *this, res;
	int temp = 0;
	for (int i = x.num.size() - 1, j = y.num.size() - 1; i >= 0 || j >= 0; --i, --j) {
		int a = i < 0 ? 0 : x.num[i];
		int b = j < 0 ? 0 : y.num[j];
		res.num.push_front((a + b + temp) % 10);
		temp = (a + b + temp) / 10;
	}
	if (temp != 0) res.num.push_front(temp);
	return res;
}
BigInt BigInt::operator * (const BigInt & y) const {
	deque<int> a, b, res;
	copy(this->num.begin(), this->num.end(), front_inserter(a));
	copy(y.num.begin(), y.num.end(), front_inserter(b));
	res.resize(a.size() + b.size() + 5);
	for (unsigned i = 0; i < a.size(); ++i) for (unsigned j = 0; j < b.size(); ++j)
		res[i + j] += a[i] * b[j];
	for (unsigned i = 0; i < res.size() - 1; ++i){
		res[i + 1] += res[i] / 10;
		res[i] %= 10;
	}
	while (res.size() >= 2 && res.back() == 0)
		res.pop_back();
	reverse(res.begin(), res.end());
	BigInt ret; ret.negative = this->negative ^ y.negative; ret.num = res;
	return ret;
}
BigInt BigInt::operator - (const BigInt & y) const {
	if (!this->negative && y.negative) return *this + abs(y);
	if (this->negative && !y.negative) return -(abs(*this) + y);
	if (this->negative && y.negative) return abs(y) - abs(*this);
	deque<int> a, b, res; BigInt ret;
	copy(this->num.begin(), this->num.end(), front_inserter(a));
	copy(y.num.begin(), y.num.end(), front_inserter(b));
	if (y > *this) swap(a, b), ret.negative = true;
	res.resize(max(a.size(), b.size()) + 5);
	for (unsigned i = 0, j = 0; i < a.size() || j < b.size(); ++i, ++j){
		int m = i < a.size() ? a[i] : 0;
		int n = j < b.size() ? b[j] : 0;
		res[i] = m - n;
	}
	for (unsigned i = 0; i < res.size() - 1; ++i) if (res[i] < 0) {
		res[i] += 10;
		--res[i + 1];
	}
	while (res.size() >= 2 && res.back() == 0)
		res.pop_back();
	reverse(res.begin(), res.end()); ret.num = res;
	return ret;
}
BigInt BigInt::operator / (const LLT & y) const {
	LLT temp = 0;
	BigInt x = (*this), res;
	for (unsigned i = 0; i < x.num.size(); ++i){
		temp = temp * 10 + x.num[i];
		res.num.push_back((int)(temp / y));
		temp %= y;
	}
	while (res.num.size() >= 2 && res.num.front() == 0)
		res.num.pop_front();
	return res;
}
LLT BigInt::operator % (const LLT & y) const {
	LLT res = 0;
	for (unsigned i = 0; i < this->num.size(); ++i)
		res = (res * 10 + this->num[i]) % y;
	return res;
}








int main()
{
	BigInt a, b;
	while (cin >> a >> b)
		cout << a + b << endl;
	return  0;
}



下面是老版的V1.0版本提供参考，使用数组实现，速度会快一些。 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#define MAXN 1024
using namespace std;

class BigInt
{
private:
    int num[MAXN];
    int len;
    int flag;
public:
    BigInt()
    {
        memset(num, 0, sizeof(num));
        len = 0;
        flag = 1;
    };
    BigInt(const int);
    BigInt(const char*);
    BigInt(const string);
    BigInt(const BigInt &x);
    BigInt &operator = (const BigInt &);

    friend istream &operator >> (istream &, BigInt &);
    friend ostream &operator << (ostream &, BigInt &);

    BigInt operator + (const BigInt &);
    BigInt operator - (const BigInt &);
    BigInt operator * (const BigInt &);
    BigInt operator / (const long long int &);
    long long int operator % (const long long int &);
    bool operator > (const BigInt &);

    friend BigInt rev(const BigInt &x);
};

//将一个int类型的变量转化为BigInt类型
BigInt::BigInt(const int x)
{
    memset(num, 0, sizeof(num));
    len = 0;
    int t;
    if(x < 0)
    {
        t = -x;
        flag = -1;
    }
    else
        t = x;
    while (t > 0)
    {
        num[len++] = t % 10;
        t = t / 10;
    }
}

//将一个C风格字符串的变量转化为BigInt类型
BigInt::BigInt(const char* str)
{
    memset(num, 0, sizeof(num));
    len = strlen(str);
    for (int i = 0; i < len; i++)
    {
        num[i] = str[i] - '0';
    }
}

//将一个string字符串的变量转化为BigInt类型
BigInt::BigInt(const string str)
{
    string temp(str);
    memset(num, 0, sizeof(num));
    len = temp.size();
    int cnt = 0;
    for (string::iterator i = temp.begin(); i != temp.end(); i++)
        num[cnt++] = *i - '0';
}

//拷贝BigInt对象
BigInt::BigInt(const BigInt &x)
{
    len = x.len;
    flag = x.flag;
    memset(num, 0, sizeof(num));
    for (int i = 0; i < len; i++)
        num[i] = x.num[i];
}

//重载赋值运算符
BigInt & BigInt::operator = (const BigInt &x)
{
    len = x.len;
    flag = x.flag;
    memset(num, 0, sizeof(num));
    for (int i = 0; i < len; i++)
        num[i] = x.num[i];
    return (*this);
}

//重载输入运算符
istream &operator >> (istream &is, BigInt &x)
{
    string temp;
    is >> temp;
    memset(x.num, 0, sizeof(x.num));
    x.len = temp.size();
    int cnt = 0;
    for (string::iterator i = temp.begin(); i != temp.end(); i++)
        x.num[cnt++] = *i - '0';
    return is;
}

//重载输出运算符
ostream &operator << (ostream &os, BigInt &x)
{
    if(x.flag == -1)
        printf("-");
    for (int i = 0; i < x.len; i++)
        printf("%d", x.num[i]);
    return os;
}

//获取翻转BigInt后的BigInt
BigInt rev(const BigInt &x)
{
    BigInt res;
    res.len = x.len;
    res.flag = x.flag;
    memset(res.num, 0, sizeof(res.num));
    for(int i=0; i<res.len; i++)
        res.num[res.len-1-i] = x.num[i];
    return res;
}

//判断两个BigInt的大小
bool BigInt::operator > (const BigInt &y)
{
    BigInt x = (*this);
    if(x.len > y.len)
        return true;
    else if(x.len < y.len)
        return false;
    else if(x.len == y.len)
    {
        for(int i=0; i<x.len; i++)
        {
            if(x.num[i] > y.num[i])
                return true;
            else if(x.num[i] < y.num[i])
                return false;
        }
        return false;
    }
}

//两个BigInt之间的加法运算
BigInt BigInt::operator + (const BigInt &y)
{
    BigInt x(*this);
    BigInt res;
    int i, j;
    int cnt = 0, temp = 0;

    for (i = x.len - 1, j = y.len - 1; i >= 0 || j >= 0; i--, j--)
    {
        int a = i < 0 ? 0 : x.num[i];
        int b = j < 0 ? 0 : y.num[j];
        res.num[cnt++] = (a + b + temp) % 10;
        temp = (a + b + temp) / 10;
    }
    if (temp != 0)
        res.num[cnt++] = temp;
    res.len = cnt;

    for (int i = 0; i < (res.len / 2); i++)
    {
        int t = res.num[i];
        res.num[i] = res.num[res.len - 1 - i];
        res.num[res.len - 1 - i] = t;
    }
    return res;
}

//两个BigInt之间的乘法运算
BigInt BigInt::operator * (const BigInt &y)
{
    BigInt a, b, res;
    BigInt ret;
    a = rev(*this);
    b = rev(y);

    for(int i=0; i<a.len; i++)
        for(int j=0; j<b.len; j++)
            res.num[i+j] += a.num[i] * b.num[j];

    for(int i=0; i<MAXN-1; i++)
    {
        res.num[i+1] += res.num[i]/10;
        res.num[i] = res.num[i]%10;
    }

    for(int i = MAXN-1; i>=0; --i)
    {
        if(res.num[i]!=0)
        {
            res.len = i + 1;
            break;
        }
    }

    if(res.len==0)
    {
        res.len = 1;
        res.num[0] = 0;
    }

    ret = rev(res);
    return ret;
}

//两个BigInt之间的减法运算
BigInt BigInt::operator - (const BigInt &y)
{
    BigInt a = rev(*this), b = rev(y);
    BigInt res, ret;

    if(b > a)
    {
        swap(a, b);
        res.flag = -1;
    }

    for(int i=0, j=0; i<a.len || j<b.len; i++, j++)
    {
        int m = i<a.len ? a.num[i] : 0;
        int n = j<b.len ? b.num[j] : 0;
        res.num[i] = m - n;
    }

    for(int i=0; i<MAXN-1; i++)
    {
        if(res.num[i]<0)
        {
            res.num[i] += 10;
            res.num[i+1]--;
        }
    }

    for(int i = MAXN-1; i>=0; --i)
    {
        if(res.num[i]!=0)
        {
            res.len = i + 1;
            break;
        }
    }

    if(res.len==0)
    {
        res.len = 1;
        res.num[0] = 0;
    }

    ret = rev(res);
    return ret;
}

//BigInt除以一个长整形运算
BigInt BigInt::operator / (const long long int &y)
{
    long long int temp = 0;
    BigInt x = (*this);
    BigInt res;
    for(int i=0; i<len; i++)
    {
        temp = temp*10 + x.num[i];
        res.num[i] = temp / y;
        temp = temp % y;
    }

    //去前导0
    int cnt = 0;
    for(int i = 0; i<MAXN; ++i)
    {
        if(res.num[i]!=0)
        {
            cnt = i;
            break;
        }
    }
    for(int i = cnt; i<MAXN; ++i)
    {
        int t = res.num[i];
        res.num[i] = res.num[i-cnt];
        res.num[i-cnt] = t;
    }

    res.len = x.len - cnt;

    return res;
}

//BigInt对一个长整形做取余运算
long long int BigInt::operator % (const long long int &y)
{
    long long int temp = 0;
    BigInt x = (*this);
    BigInt res;
    for(int i=0; i<len; i++)
    {
        temp = temp*10 + x.num[i];
        res.num[i] = temp / y;
        temp = temp % y;
    }
    return temp;
}








int main()
{
    return  0;
}


 

 

 

转载于:https://www.cnblogs.com/kunsoft/p/5312800.html

weixin_30625691
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大数类模板
blues 的博客
05-25 350
大数类模板 #define MAXN 9999 #define MAXSIZE 10 #define DLEN 4 class BigNum { private: int a[500]; //可以控制大数的位数 int len; //大数长度 public: BigNum(){ len = 1; memset(a, 0, sizeof(a
数组类模板
qq_27158571的博客
10-12 396
静态数组：具有固定元素个数的群体，其中的元素可以通过下标直接访问。缺点：数组大小在编译时就已经确定，在运行时无法修改大小。 动态数组（vector）：动态数组由一系列位置连续的，任意数量相同类型的元素组成。优点：元素个数可在程序运行时改变。 //通过例子，了解如何封装动态数组类，注意看注释！！！ array.h #ifndef ARRAY_H #define ARRAY_H #include <cassert> template <class T> cla..
大整数运算模板_C语言
最新发布
afinis的博客
11-03 96
大整数：高精度整数，其含义就是用基本数据类型无法存储其精度的整数。
Train Problem II hdu 1023
保持饥饿，保持愚昧
07-27 291
Train Problem II hdu1023大数 和 卡特兰数大数模板#include<string> #include<iostream> #include<iosfwd> #include<cmath> #include<cstring> #include<stdlib.h> #include<stdio.h> #include<cstring> #define MAX_L 2005 //最
高精度模板
glq007的acm的奋斗
11-06 679
转载至http://blog.csdn.net/code4101/article/details/38705155
大整数模版
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
06-20 1139
高精度模版： 稍加整合 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;algorithm&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;vector&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;iostream&am
大整数模板
bandilan2400的博客
08-05 91
　　稍微测试了一下感觉还行，可能有BUG，如果发现了还望告诉我。代码是C++11写的，要有能支持constexpr这些关键字的编译器才可以编译出来。 　　update: 2016.8.5 15:51 加了个可以转出字符串的功能 1 #pragma once 2 #ifndef BigIntNums_H 3 #define BigIntNums_H 4 5...
大整数正负类型class模板
07-22
大整数类型模板，各个接口已经封装完成，拿到就可以用，万分推荐！！！ 大整数类型模板，各个接口已经封装完成，拿到就可以用，万分推荐！！！ 大整数类型模板，各个接口已经封装完成，拿到就可以用，万分推荐！！！...
C++堆栈类模板实现代码
08-26
C++堆栈类模板实现代码 C++堆栈类模板是指使用C++语言实现的堆栈类模板，它可以存储不同类型的数据。下面是堆栈类模板的实现代码： 首先，我们需要定义一个堆栈类模板MyStack，使用模板参数T来表示存储的数据类型...
大整数类c++实现
01-01
这是我的处女发，呵呵。 言归正传，这是我们老师提供给我们让我们编写高精度有理数用的，这个类包很小，功能也只是一些基本运算。我自己也曾经试着写一个大整数类，但和大多数初学者一样卡在了除法上。在这个类包中，除法用的是折半试商法，但我个人认为效率很低。 还有许多大整数类包，可以在网上下到，但我觉得这个对初学者很好。特别是对运算符重载的学习。 另外，我从一本数值算法书中也找到了一个高精度运算的实现。有点难，本人数值分析学得糟，正在着磨中。但我学习数值分析的过程中认识到的是：数值解再精确也是一个逼近值。我不理解怎么会用数值算法解决高精度运算呢。 我把书向大家推荐一下，希望大家一起探讨。《Numerical Recipes in c++》作者：William H.press, Saul A.Teukolsky等，电子工业出版社出版的翻译版《c++数值算法》第668页。
BigInteger(大整数类，部分模板)
01-08
GarbaGe的东西降价了！！！一分，就一分！！！好东西一定要分享啊啊啊！！！ 本模板为高精度模板，大概可存储200位。 目前只支持：输入、输出、赋值、加法。 会不定期更新，请多多资瓷！
c++高效的圧位大整数模板
10-12
c++高效的圧位大整数模板，可以在acm等比赛中方便快速的使用，模板的实现采用圧位技术，比较高效
大整数类求圆周率
11-28
自己重载了一个大整数的类，并且使用它求π，可以精确到120多位有效数字。 将代码和生产文件一并打包。
学校（fzu）布置的作业，自己写的巨型整数类（C++）
09-25
学校（fzu）布置的作业，完全自己手写的巨型整数类（C++），记得当时写了好久，特别是重载巨型整数相乘，相除和相加的函数。
大整数的运算
03-15
在计算机科学中，大整数运算通常涉及到处理超出普通整型变量范围的数值。这篇描述提到了使用VC++ 6.0开发的大整数运算程序，该程序利用链表数据结构来存储和操作大整数，而不依赖于C++标准库中的`list`容器或内置...
C++类模板与模板类深入详解
09-04
例如，如果我们有一个类模板`Stack`，实例化`Stack<int>`就会得到一个处理整数的栈类。 6. 函数模板： 函数模板与类模板类似，但它们定义的是通用的函数而非类。函数模板可以接受不同类型参数，通过模板参数实现...
大整数类（模板）
dianshu1593的博客
09-13 94
1 /*支持加减乘除、取模、赋值、输入输出*/ 2 const int MAX_SIZE = 5000 + 10; //最大位数 3 4 struct BigInteger 5 { 6 int len, s[MAX_SIZE]; 7 BigInteger() 8 { 9 memset(s,...
用C++设计并实现一个大整数类
qianggezhishen的专栏
07-27 5480
http://blog.csdn.net/hackbuteer1/article/details/6595881

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值