C++类实现大整数

最新推荐文章于 2024-07-29 08:05:01 发布
最新推荐文章于 2024-07-29 08:05:01 发布
阅读量1.3k 收藏 9
点赞数 5
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MuQYun/article/details/134748609
版权

概要

在计算机科学和工程中，整数类型有一个上限，称为其最大值或最大表示值，这限制了数字的大小范围。在一些应用中，需要处理比这个上限更大的整数，这时就需要使用大整数类。

大整数类允许处理比计算机所提供的整数类型更大的整数，通常是以字符串形式存储，可以进行算术运算、比较和转换等操作。这在密码学、数值计算、物理仿真、金融等领域中非常有用。

比如在密码学中，RSA加密算法就需要对非常大的整数进行加密和解密。在数值计算中，需要进行高精度计算，避免舍入误差，保证计算结果的准确性。在物理仿真中，需要模拟非常大或非常小的量。在金融领域中，需要处理非常大的金额或精确的计算结果。

因此，大整数类是一个非常有用的工具，可以扩展计算机的数字处理能力，解决很多实际问题。

然而，C++并没有自己的大整数类，因此便想要自己实现一个头文件，方便一般高精度计算的使用。

备注

这里实现的大整数类只有逻辑运算和+-*/基本操作，以及重载输入输出，并且无法输入负数，只有在实现减法时，可以输出负数。因此有一定的局限性，有时间的话我会将取模，幂运算，自增，自减等加上去的！

具体实现

1.定义大整型类

用数组模拟大数，读入使用字符串，并且倒序放置

即  123456-->654321 进行存放，1记为第一位

typedef class BigInt {
	private:
		int num[MAXN];
		int len;
		bool sign;
	public:
		static int max_Big(int x, int y) {
			return x > y ? x : y;
		}
		BigInt(int x) { //初始化使得大整型能够表示整型
			memset(num, 0, sizeof(num));
			for (len = 1; x; len++) {
				num[len] = x % 10;
				x /= 10;
			}
			sign = 1;
			len--;//由于上述循环中len多加了一次，因此这里减去
		}
		BigInt() {
			memset(num, 0, sizeof(num));
			len = 0;
			sign = 1;
		}
		BigInt(std::string s) {
			len = s.length();
			int cnt = len - 1;
			for (int i = 1; i <= len; i++) {
				num[i] = s[cnt--] - '0';
			}
			sign = 1;
		}
		BigInt(char *s) {
			len = strlen(s);
			int cnt = 1;
			for (int i = len - 1; i >= 0; i--) num[cnt++] = s[i] - '0';
		}
		void flatten(int L) { //进行展平操作
			len = L;
			for (int i = 1; i <= len; i++) {
				num[i + 1] += num[i] / 10;
				num[i] %= 10;
			}
			while (!num[len]) { //删除多余位数
				len--;
			}
		}
		friend std::ostream& operator<<(std::ostream&iout, BigInt&I1);
		friend std::istream& operator>>(std::istream&iint, BigInt&I1);
		BigInt& operator = (const BigInt &I) {  //重载赋值运算符
			len = I.len;
			sign=I.sign;
			memset(num, 0, sizeof(num));
			for (int i = 1; i <=len; i++)
				num[i] = I.num[i];
			return *this;
		}
		friend BigInt operator+(BigInt&I1, BigInt&I2);
		friend BigInt operator-(BigInt&I1, BigInt&I2);
		friend BigInt operator*(BigInt&I1, BigInt&I2);
		friend BigInt operator/(BigInt I1, BigInt&I2);//大整型除以大整型-减法模拟除法
		friend BigInt operator/(BigInt&I1, int I2);//大整型除以整型-逐位试商法
		friend bool operator<(const BigInt&I1, const BigInt&I2);
		friend bool operator>(const BigInt&I1, const BigInt&I2);
		friend bool operator!=(const BigInt&I1, const BigInt&I2);
		friend bool operator==(const BigInt&I1, const BigInt&I2);
		friend bool operator<=(const BigInt&I1, const BigInt&I2);
		friend bool operator>=(const BigInt&I1, const BigInt&I2);
} BigInt;

2.算数运算符重载

Ⅰ.加法重载

将每一位的数加起来，最后一次性铺平即可

BigInt operator+(BigInt&I1, BigInt&I2) {
	int L = BigInt::max_Big(I1.len, I2.len) + 1;
	BigInt I3;
	for (int i = 1; i <= L; i++) {
		I3.num[i] = I1.num[i] + I2.num[i];
	}
	I3.flatten(L);
	return I3;
}

 以下是铺平操作的代码

void flatten(int L) { //进行展平操作
			len = L;
			for (int i = 1; i <= len; i++) {
				num[i + 1] += num[i] / 10;
				num[i] %= 10;
			}
			while (!num[len]) { //删除多余位数
				len--;
			}
		}
Ⅱ.减法重载

如果减数大于被减数，则倒置，即让减数减去被减数，最后在结果前加一个符号即可。

利用我们小学学习的知识：减法的竖式计算，向前一位借一位进行计算。

BigInt operator-(BigInt&I1, BigInt&I2) {
	int L = BigInt::max_Big(I1.len, I2.len);
	BigInt i1, i2, I3;
	if (I1 < I2) {
		i1 = I2;
		i2 = I1;
		I3.sign = 0;
	} else {
		i1 = I1;
		i2 = I2;
		I3.sign = 1;
	}
	for (int i = 1; i <= L; i++) {
		if (i1.num[i] < i2.num[i]) {
			i1.num[i + 1]--;
			i1.num[i] += 10;
		}
		I3.num[i] = i1.num[i] - i2.num[i];
	}
	while (I3.num[L] == 0 && L > 1) L--;
	I3.len = L;
	return I3;
}
Ⅲ.乘法重载

第一个数的第i位×第二个数的第j位的贡献在结果的第i+j-1的位置上。

完成后，将结果数铺平即可。

BigInt operator*(BigInt&I1, BigInt&I2) {
	BigInt I3;
	int len1 = I1.len, len2 = I2.len;
	int L = len1 + len2;
	for (int i = 1; i <= len1; i++)
		for (int j = 1; j <= len2; j++) {
			I3.num[i + j - 1] += I1.num[i] * I2.num[j];
		}
	I3.flatten(L);
	return I3;
}
Ⅳ.除法重载 

 ①大数/小数

使用逐位试商法进行计算，类似于除法的竖式计算

BigInt operator/(BigInt&I1, int I2) {
	BigInt I3;
	int x = 0;
	int len = I1.len;
	for (int i = len; i >= 1; i--) {
		I3.num[i] = (x * 10 + I1.num[i]) / I2;
		x = ((x * 10 + I1.num[i])) % I2;
	}
	I3.flatten(len);
	return I3;
}

②大数/大数

使用减法模拟除法 

 

BigInt operator/(BigInt I1, BigInt&I2) {
	BigInt I3;
	int len1 = I1.len, len2 = I2.len;
	int start = len1 - len2 + 1;
	for (int i = start; i >= 1; i--) {
		BigInt tmp1, tmp2(10);
		tmp1 = I2;
		while (tmp1.len < i) {
			tmp1 = tmp1 * tmp2;
		}
		while (I1 >= tmp1) {
			I3.num[i]++;
			I1 = I1 - tmp1;
		}
	}
	I3.flatten(start);
	return I3;
}

 3.赋值运算符，输入输出运算符重载

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

要注意的是，该赋值运算符在类内定义 

Ⅱ.输入输出运算符重载
std::istream& operator>>(std::istream&iint, BigInt&I1) { //重载输入
	std::string s;
	iint >> s;
	I1.len = s.length();
	int cnt = I1.len - 1;
	for (int i = 1; i <= I1.len; i++) {
		I1.num[i] = s[cnt--] - '0';
	}
	return iint;
}
std::ostream& operator<<(std::ostream&iout, BigInt &I1) { //重载输出
	if (!I1.sign) std::cout<< '-';
	for (int i = BigInt::max_Big(I1.len, 1); i >= 1; i--) {
		iout << I1.num[i];
	}
	return iout;
}

 4.逻辑运算符重载

bool operator<(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 < len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] < I2.num[i];
	}
	return false;
}
bool operator<=(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 < len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] < I2.num[i];
	}
	return true;
}
bool operator>(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 > len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] > I2.num[i];
	}
	return false;
}
bool operator>=(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 > len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] > I2.num[i];
	}
	return true;
}
bool operator==(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return false;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return false;
	}
	return true;
}
bool operator!=(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return true;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return true;
	}
	return false;
}

完整代码

#ifndef BIGINT_H
#define BIGINT_H
#define MAXN 100000
#include <string.h>
#include <iostream>
#include <string>
typedef class BigInt {
	private:
		int num[MAXN];
		int len;
		bool sign;
	public:
		static int max_Big(int x, int y) {
			return x > y ? x : y;
		}
		BigInt(int x) { //初始化使得大整型能够表示整型
			memset(num, 0, sizeof(num));
			for (len = 1; x; len++) {
				num[len] = x % 10;
				x /= 10;
			}
			sign = 1;
			len--;//由于上述循环中len多加了一次，因此这里减去
		}
		BigInt() {
			memset(num, 0, sizeof(num));
			len = 0;
			sign = 1;
		}
		BigInt(std::string s) {
			len = s.length();
			int cnt = len - 1;
			for (int i = 1; i <= len; i++) {
				num[i] = s[cnt--] - '0';
			}
			sign = 1;
		}
		BigInt(char *s) {
			len = strlen(s);
			int cnt = 1;
			for (int i = len - 1; i >= 0; i--) num[cnt++] = s[i] - '0';
		}
		void flatten(int L) { //进行展平操作
			len = L;
			for (int i = 1; i <= len; i++) {
				num[i + 1] += num[i] / 10;
				num[i] %= 10;
			}
			while (!num[len]) { //删除多余位数
				len--;
			}
		}
		friend std::ostream& operator<<(std::ostream&iout, BigInt&I1);
		friend std::istream& operator>>(std::istream&iint, BigInt&I1);
		BigInt& operator = (const BigInt &I) {  //重载赋值运算符
			len = I.len;
			sign=I.sign;
			memset(num, 0, sizeof(num));
			for (int i = 1; i <=len; i++)
				num[i] = I.num[i];
			return *this;
		}
		friend BigInt operator+(BigInt&I1, BigInt&I2);
		friend BigInt operator-(BigInt&I1, BigInt&I2);
		friend BigInt operator*(BigInt&I1, BigInt&I2);
		friend BigInt operator/(BigInt I1, BigInt&I2);//大整型除以大整型-减法模拟除法
		friend BigInt operator/(BigInt&I1, int I2);//大整型除以整型-逐位试商法
		friend bool operator<(const BigInt&I1, const BigInt&I2);
		friend bool operator>(const BigInt&I1, const BigInt&I2);
		friend bool operator!=(const BigInt&I1, const BigInt&I2);
		friend bool operator==(const BigInt&I1, const BigInt&I2);
		friend bool operator<=(const BigInt&I1, const BigInt&I2);
		friend bool operator>=(const BigInt&I1, const BigInt&I2);
} BigInt;
bool operator<(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 < len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] < I2.num[i];
	}
	return false;
}
bool operator<=(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 < len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] < I2.num[i];
	}
	return true;
}
bool operator>(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 > len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] > I2.num[i];
	}
	return false;
}
bool operator>=(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return len1 > len2;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return I1.num[i] > I2.num[i];
	}
	return true;
}
bool operator==(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return false;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return false;
	}
	return true;
}
bool operator!=(const BigInt&I1, const BigInt&I2) {
	int len1 = I1.len, len2 = I2.len;
	if (len1 != len2) {
		return true;
	}
	for (int i = len1; i >= 1; i--) {
		if (I1.num[i] != I2.num[i]) return true;
	}
	return false;
}
BigInt operator+(BigInt&I1, BigInt&I2) {
	int L = BigInt::max_Big(I1.len, I2.len) + 1;
	BigInt I3;
	for (int i = 1; i <= L; i++) {
		I3.num[i] = I1.num[i] + I2.num[i];
	}
	I3.flatten(L);
	return I3;
}
BigInt operator-(BigInt&I1, BigInt&I2) {
	int L = BigInt::max_Big(I1.len, I2.len);
	BigInt i1, i2, I3;
	if (I1 < I2) {
		i1 = I2;
		i2 = I1;
		I3.sign = 0;
	} else {
		i1 = I1;
		i2 = I2;
		I3.sign = 1;
	}
	for (int i = 1; i <= L; i++) {
		if (i1.num[i] < i2.num[i]) {
			i1.num[i + 1]--;
			i1.num[i] += 10;
		}
		I3.num[i] = i1.num[i] - i2.num[i];
	}
	while (I3.num[L] == 0 && L > 1) L--;
	I3.len = L;
	return I3;
}
BigInt operator*(BigInt&I1, BigInt&I2) {
	BigInt I3;
	int len1 = I1.len, len2 = I2.len;
	int L = len1 + len2;
	for (int i = 1; i <= len1; i++)
		for (int j = 1; j <= len2; j++) {
			I3.num[i + j - 1] += I1.num[i] * I2.num[j];
		}
	I3.flatten(L);
	return I3;
}
BigInt operator/(BigInt&I1, int I2) {
	BigInt I3;
	int x = 0;
	int len = I1.len;
	for (int i = len; i >= 1; i--) {
		I3.num[i] = (x * 10 + I1.num[i]) / I2;
		x = ((x * 10 + I1.num[i])) % I2;
	}
	I3.flatten(len);
	return I3;
}
BigInt operator/(BigInt I1, BigInt&I2) {
	BigInt I3;
	int len1 = I1.len, len2 = I2.len;
	int start = len1 - len2 + 1;
	for (int i = start; i >= 1; i--) {
		BigInt tmp1, tmp2(10);
		tmp1 = I2;
		while (tmp1.len < i) {
			tmp1 = tmp1 * tmp2;
		}
		while (I1 >= tmp1) {
			I3.num[i]++;
			I1 = I1 - tmp1;
		}
	}
	I3.flatten(start);
	return I3;
}
std::istream& operator>>(std::istream&iint, BigInt&I1) { //重载输入
	std::string s;
	iint >> s;
	I1.len = s.length();
	int cnt = I1.len - 1;
	for (int i = 1; i <= I1.len; i++) {
		I1.num[i] = s[cnt--] - '0';
	}
	return iint;
}
std::ostream& operator<<(std::ostream&iout, BigInt &I1) { //重载输出
	if (!I1.sign) std::cout<< '-';
	for (int i = BigInt::max_Big(I1.len, 1); i >= 1; i--) {
		iout << I1.num[i];
	}
	return iout;
}

#endif

实际演示

将代码包裹成头文件，放在项目文件夹中，即可调用大数型了。

#include "BIGINT.h"
using namespace std;
int main(){
	BigInt I1,I2;
	BigInt I3;
	cin>>I1>>I2;
	I3=I1+I2;
	cout<<"I1+I2="<<I3<<endl;
	I3=I1-I2;
	cout<<"I1-I2="<<I3<<endl;
	I3=I1*I2;
	cout<<"I1*I2="<<I3<<endl;
	I3=I1/I2;
	cout<<"I1/I2="<<I3<<endl;
	return 0;
}

 就这样啦~谢谢观看！

MuQYun
关注
大整数类型的设计
12-08
定义大整数类,重载算术运算+ - *等运算符与== > < 关系运算符
C++大整数类（支持多种进制）
[PE]经典八炮的博客
05-14 6503
一、简介 项目名称：C++大整数类 开发环境：Visual Studio 2022 C++标准：C++20 C++中是有整数类型的，最常用的就是int型。但是，C++自带的整数类型是有大小范围的，可能会溢出，产生很多令人头疼的错误。 示例： #include<iostream> //#include"CBigInt.h" using namespace std; int main() { int t = 1; for (int i = 0; i < 100; i++) { t *
【C++进阶】BigInt之Number类的简单实现
最新发布
m0_62599305的博客
07-29 327
在现代计算中，处理超出标准数据类型范围的大整数问题是一个常见的需求。在 C++ 中，标准数据类型如 int 或 long long 只能表示有限范围的整数，这在处理大数运算时会遇到局限。为了克服这个问题，我们可以实现一个 BigInt 类，用于处理任意大小的整数。在这篇文章中，我们将简要介绍如何设计和实现一个简单的 Number 类，以支持大整数的存储和基本运算。通过实现一个简单的 Number 类，我们能够在 C++ 中处理任意大小的大整数。
C++处理大数问题/高精度问题,看这就够了
热门推荐
北北北
07-28 1万+
将带你了解 1.大数加法 2.大数减法 3.辨识负数的大数加减法 4.大数乘法 5.大数除法
基于C++实现的大整数计算
01-13 1678
基于C++实现的大整数计算
简单介绍C++大整数类
m0_65305142的博客
07-02 1973
比如字符串是字符“1234”的组合，通过上述步骤var中得到的是真正int型1234。众所周知有符号的int型最大数据为2147483647（一共10位），所以取BASE为8位，且代码保证进入vector的数据都小于BASE，所以一定不会超限。，作用是将string类型的第一个元素值返回，达到的是一个将C++风格字符串转换为C风格的字符数组的效果。，表示取出原字符串中下标从start开始的长度为n的子字符串，返回值同样是string。同理，取WIDTH为8保证了每一次只录入长度≤8的数据，小于int。
C++实现大整数乘法
08-25
C++实现大整数乘法 在计算机科学中，大整数乘法是指对两个大整数进行乘法运算的过程。由于大整数的存在，普通的整数乘法算法无法满足要求，因此需要专门设计大整数乘法算法。在C++中实现大整数乘法可以使用笛卡尔相...
C++实现的大整数四则运算
12-25
C++作为一门强类型且高效的语言，虽然标准库中并没有内置大整数支持，但可以通过自定义数据结构和算法来实现。这个项目就是基于这样的背景，作者尝试实现了大整数的四则运算。 首先，我们来看大整数类的设计。在C++...
C++实现大整数乘法（字符串乘法）
08-25
"C++实现大整数乘法（字符串乘法）" 本文主要介绍了C++实现大整数乘法（字符串乘法）的方法和实现代码，旨在帮助读者了解大整数乘法的实现原理和方法。 大整数乘法的概念 大整数乘法是指对两个大整数进行乘法运算...
c++-大整数bigint加法实现
06-15
大整数加法实现 进行了良好封装
c++的任意大小整数类
01-27
总之，C++的任意大小整数类是一种用于处理大整数的高级数据结构，它通过自定义的类或第三方库实现，提供了丰富的算术和位操作功能，适用于加密算法、数值计算、游戏开发等多个领域。通过理解和掌握BigInt的实现，...
C/C++高精度运算（大整数运算）
ZER00000001的博客
11-07 2584
众所周知，最大的整型long long的范围是【-9223372036854775808~9223372036854775807】，即使是无符号位的unsigned long long最大值也只是扩大一倍，那当题目需要用到或需要输出比long long类型的范围还要大的数字时，我们是不是就不能用常规办法去接收这些数字了。这个时候使用大整数就可以解决上述问题——也就是解决接收超出整型范围数字的问题。
C++大数BigInt
Happig的博客
07-24 2738
前言 一直在用板子，然后考虑到有些细节还不是很清楚，就整理一下吧。然后没有按板子来写，但是思想基本一致，因为我的板子是每四位合并成一位，也就是将大数看做一个100001000010000进制数 构造和输出 大数一位位地输入比较慢，因此一般采用字符串输入，然后将字符串转化为大数 注意需要从后向前存，运算时从前向后运算，输出时从后向前输出 const int maxn=1005; struct BigInt{ int a[maxn]; int len; BigInt(){ len=1
C++之高精度算发
千里之行，始于足下
03-05 262
前言:由于计算机运算是有模运算,数据范围的表示有一定限制,如整型int(C++中int 与long相同)表达范围是(-2^31~2^31-1),unsigned long(无符号整数)是(0~2^32-1),都约为几十亿.如果采用实数型,则能保存最大的double只能提供15~16位的有效数字,即只能精确表达数百万亿的数.因此,在计算位数超过十几位的数时,不能采用现有类型,只能自己编程计算.高精度...
大整数类设计（C++）
qq_42731435的博客
01-04 4377
简介 在平时的功能需求中，C/C++语言内置的整形变量表示范围已经足够大了，但是在一些特定的场合，例如解决数学问题的时候，可能需要表示极大的整数。这时候C/C++语言提供的类型就不能满足需求了，需要自己来实现超大整数的实现，当然仅仅是能够存储超大整数还不行，还要能够进行运算。 设计功能 能够表达正数与负数 能够由整形或字符串转化得到 能够使用 + - * / 等符号进行运算 可以与int 类型进行混合运算 可以使用输入输出流 当发生除数为零等错误时会抛出异常 源码分享 头文件：BigInt.h #inc
c++实现大整数-数据结构
GuItArIsT_的博客
10-04 1798
c++实现大整数-数据结构 在C++中，整型有short int,long int ,long long，其中long long可表示范围最大，为[-2^63+1 , 2^63-1].但当遇到需要表示更大的整数的时候，就需要其他的方法来解决了。题主在刷算法题的时候遇到需要用大整数表示的题目，做完后特地对大整数类的部分常用运算和操作符进行完善与补充，并封装成类。 C++大整数的本质为容器(最好为顺序容器)，原理为将一个整数的每个基数用容器的每个元素表示，比如若整数“12345”用大整数表示，容器的每个元素的
C++大整数
YYC的专栏
04-22 3048
这两天一直在利用一些课余的琐碎时间在写C++大整数，昨天晚上终于基本完工了，利用到的思想就是： 用一个连续的int型的存储空间去表示大整数和进行运算。在运算时将该大整数拆分成一个多项式，然后按照 多项式的规则进行运算，最后在输出显示该大整数时再将该大整数的每一项进行调整到0到9之间。本程序的 缺点就是存储空间利用率较低，有待优化的地方还很多。嗯。。等过几天有时间了再来优化吧。 BigInt
C++ 大数处理
Try_You_Can的专栏
09-07 3046
C++编程中，常会处理一些大数的操作，例如幂指数计算，组合数计算，大数之间的加减法等。
C++ long数据类型：超长整型数据的存储和计算
很酷的站长的博客
09-01 6153
long数据类型是一个整型，存储4个字节，可以表示一个范围为-2,147,483,648到2,147,483,647的整数。在64位系统上，long长度为8个字节。如果需要存储更大范围的整数，可以使用long long数据类型，它能够存储更大的整数。long long数据类型存储8个字节，可以表示-9,223,372,036,854,775,808到9,223,372,036,854,775,807的整数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值