Cómo lidiar con números extremadamente largos en C++ (los enteros de tipo largo no se pueden almacenar)
En C++, si el número excede el rango del tipo largo, puede considerar usar cadenas o bibliotecas de terceros (como Boost.Multiprecision) para representar y manejar números extremadamente largos. Para utilizar bibliotecas de terceros, debe descargar e instalar las bibliotecas de terceros necesarias, que no se presentarán aquí.
A continuación se ofrece una introducción al uso de cadenas para representar y manejar números muy largos. Este artículo presentará el uso de cadenas C ++ para implementar operaciones de suma, resta, multiplicación y división de números extremadamente largas.
1. Determine si un número muy grande no negativo es par o impar. El código fuente es el siguiente:
#include <iostream>
#include <string>
using namespace std;
int main() {
//string s = "123456789123456789123456789";
cout << "请输入一个正整数：" << endl;
cin >> s;
// s.size()是字符串的长度，即由多少字符组成的， 字符串的最后一位字符即s[s.size() - 1]
char c = s[s.size() - 1];
cout << "最后一位数字是" << c << endl;
// 将一个整数数字字符变成整数，我们只需要将它减字符'0'
int i = c - '0';
if (i % 2 == 0) {
cout << s << "是偶数";
} else {
cout << s << "是奇数";
}
return 0;
}
2. Determina el tamaño de dos números enteros positivos muy grandes.
#include <iostream>
#include <string>
using namespace std;
bool Lower(string str1, string str2){
//长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
return str1.size()<str2.size()||(str1.size()==str2.size()&&str1<str2);
}
int main() {
cout << "请输入两个超大正整数：" << endl;
string a, b;
cin >> a >> b;
if (Lower(a, b)){
cout << a << "小于" << b << endl;
}
else{
cout << a << "大于" << b << endl;
}
return 0;
}
Los métodos de implementación de operaciones de suma, resta, multiplicación y división se presentan a continuación. En particular, las operaciones de suma y resta se limitan a operaciones de números enteros no negativos, porque las operaciones de suma y resta de números negativos pueden ser equivalentes a alguna forma de operaciones de suma o resta, por lo que no se consideran; las operaciones de multiplicación y división solo consideran grandes operaciones con números enteros, no decimales Cálculo; la división solo considera operaciones con números enteros grandes y el resultado del cálculo tiene una precisión de 6 decimales (se descarta directamente después de 6 decimales).
Referencia https://blog.songjiahao.com/archives/382
3. Suma de números enteros grandes no negativos
La implementación de la suma de números grandes imita nuestro método de cálculo de expresiones verticales: comenzando desde los dígitos de las unidades, sumando uno por uno, solo considere el acarreo cada vez. Dado que la posición 0 de la cadena leída es el bit más alto, accedemos a la cadena en orden inverso y luego calculamos cada bit. De manera similar, debido a que cada bit obtenido durante el cálculo está en orden inverso, el resultado final debe invertirse.
La suma puede dar como resultado un dígito final más (llevado desde el bit más alto), así que recuerde manejarlo.
Finalmente, consideremos algunos casos especiales, por ejemplo, si ambos números son 0 o uno de ellos es 0, podemos obtener el resultado rápidamente y guardar el proceso transversal.
implementar código
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//判断是否为0，全部为0的数字就是0，比如00000
bool CheckZero(const string &str){ //检查是否等于0
int size=str.size(); //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
for(int i=0;i<size;i++)
if(str[i]!='0') return false;
return true;
}
string Add(string str1, string str2){
//关于0的处理
if(CheckZero(str1)&&CheckZero(str2)) return "0"; //如果都是0
else if(CheckZero(str1)) return str2; //如果有个一为0
else if(CheckZero(str2)) return str1;
string ans;
int i=str1.size()-1,j=str2.size()-1;
int flag=0; //进位标记
while(i>=0||j>=0||flag){
int numa=i>=0?str1[i--]-'0':0; //如果所有位都访问完毕，对应的位置用0代替
int numb=j>=0?str2[j--]-'0':0;
flag=numa+numb+flag; //计算两位的和
ans+='0'+flag%10; //取个位保存在答案中
flag/=10; //计算进位
}
reverse(ans.begin(),ans.end());
return ans;
}
int main(){
cout << "请输入两个正整数：" << endl;
string a, b;
cin >> a >> b;
string result = Add(a, b);
cout << "和：" << result << endl;
return 0;
}
4. Resta de números enteros grandes no negativos
La implementación de la resta de números grandes también imita nuestro método de cálculo de expresiones verticales. A partir del dígito de las unidades, se calcula un dígito cada vez. Primero, en función de si se toma prestado el siguiente dígito, el dígito prestado se resta primero y luego se juzga si el dígito actual se resta lo suficiente. Si se necesita un dígito prestado , se toma prestado el dígito anterior y luego se resta hasta completar la operación. De manera similar, debido a que tenemos que calcular a partir del dígito de las unidades, los resultados calculados deben estar en orden inverso. Finalmente, debemos recordar invertir los resultados.
Durante la resta, pueden aparecer 0 a la izquierda. Recuerde borrar los ceros a la izquierda.
Finalmente, consideremos algunos casos especiales, como que dos números sean iguales o un número sea 0. Podemos obtener el resultado directamente, evitando así un procesamiento complicado.
implementar código
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//判断两个超大正整数的大小
bool Lower(string str1, string str2){
//长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
return str1.size()<str2.size()||(str1.size()==str2.size()&&str1<str2);
}
//判断是否为0，全部为0的数字就是0，比如00000
bool CheckZero(const string &str){ //检查是否等于0
int size=str.size(); //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
for(int i=0;i<size;i++)
if(str[i]!='0') return false;
return true;
}
string Sub(string str1, string str2){
//处理0的情况
if(str1==str2||(CheckZero(str1)&&CheckZero(str2))) return "0"; //如果两数相等或者都是0
else if(CheckZero(str1)) return "-"+str2; //如果第一个数字为0
else if(CheckZero(str2)) return str1; //如果第二个数字为0
//定正负
int negative=0; //结果的正负号
if(Lower(str1,str2)){
swap(str1,str2); //保证str1大于str2
negative=1; //如果str1小于str2，则结果过为负值
}
string ans;
int i=str1.size()-1,j=str2.size()-1;//逆序开始处理
int flag=0; //借位标记
while(i>=0||j>=0){
int numa=i>=0?str1[i--]-'0':0; //取每一位，因为长度可能不同所以当某一个已经读取完毕时对应位置取0
int numb=j>=0?str2[j--]-'0':0;
numa-=flag; //先减去借位
if(numa<numb){ //如果不够减则向上一位借位（只可能借一位）
numa+=10; //借位并记录借位
flag=1;
}
else flag=0; //如果不借位，则借位标记为0
ans+='0'+numa-numb; //计算当前位置并保存
}
i=ans.size()-1;
while(ans[i]=='0') i--;
ans=ans.substr(0,i+1); //去除前导0,如111-110=1
if(negative) ans+='-'; //如果计算结果是负数，添加负数符号
reverse(ans.begin(),ans.end()); //因为是逆序计算得到的结果，所以需要翻转一下
return ans;
}
int main(){
cout << "请输入两个正整数：" << endl;
string a, b;
cin >> a >> b;
string result = Sub(a, b);
cout << "差： " << result << endl;
return 0;
}
5. Multiplicación de números enteros grandes
La implementación de la multiplicación de números grandes también utiliza nuestro método de cálculo vertical. A partir del dígito de las unidades, calcule el producto del multiplicando y el multiplicador un dígito cada vez, y luego use la suma de números grandes que escribimos para lograr la acumulación del resultado final. Sin embargo, la multiplicación de números grandes debe considerar la cuestión de lo positivo y lo negativo, por lo que es necesario procesar los signos positivos y negativos. El uso de XOR en los signos de dos números puede, en última instancia, determinar si el resultado del producto es positivo o negativo.
Multiplicación, porque cada dígito del multiplicador tiene un peso correspondiente (cien millones), por lo que cuando calculamos el producto de cada dígito del multiplicador, debemos considerar el peso de esa posición y sumar el valor correspondiente después del producto. de cero es suficiente.
Finalmente, consideramos algunos casos especiales, por ejemplo, siempre que uno de los dos números sea 0, el resultado es 0.
implementar código
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//判断两个超大正整数的大小
bool Lower(string str1, string str2){
//长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
return str1.size()<str2.size()||(str1.size()==str2.size()&&str1<str2);
}
//判断是否为负，只需要判断第一位是不是负号即可，这里不考虑正号的存在，即认为不使用正号
bool CheckNegative(const string &str){ //检查是否为负数
return str[0]=='-';
}
//判断是否为0，全部为0的数字就是0，比如00000
bool CheckZero(const string &str){ //检查是否等于0
int size=str.size(); //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
for(int i=0;i<size;i++)
if(str[i]!='0') return false;
return true;
}
string Add(string str1, string str2){
//关于0的处理
if(CheckZero(str1)&&CheckZero(str2)) return "0"; //如果都是0
else if(CheckZero(str1)) return str2; //如果有个一为0
else if(CheckZero(str2)) return str1;
string ans;
int i=str1.size()-1,j=str2.size()-1;
int flag=0; //进位标记
while(i>=0||j>=0||flag){
int numa=i>=0?str1[i--]-'0':0; //如果所有位都访问完毕，对应的位置用0代替
int numb=j>=0?str2[j--]-'0':0;
flag=numa+numb+flag; //计算两位的和
ans+='0'+flag%10; //取个位保存在答案中
flag/=10; //计算进位
}
reverse(ans.begin(),ans.end());
return ans;
}
string Mul(string str1, string str2){
if(CheckZero(str1)||CheckZero(str2)) return "0"; //如果有一个为0,则结果为0
int negative=0,negastr1=0,negastr2=0; //定正负
if(CheckNegative(str1)){ //确定正负号标记，并且去掉-字符
negastr1=1; str1=str1.substr(1,str1.size()-1);
}
if(CheckNegative(str2)){
negastr2=1; str2=str2.substr(1,str2.size()-1);
}
negative=negastr1^negastr2; //异或运算确定结果的正负号
string ans;
if(Lower(str1,str2)) swap(str1,str2); //保证str1大于等于str2
int size1=str1.size(),size2=str2.size();
for(int i=size2-1;i>=0;i--){ //遍历较小数字的每一位
string temp(size2-1-i,'0'); //temp为str1乘以str2[i]的积，根据str2[i]的权重（个十百千万，补充对应个数的0）
int flag=0; //进位标记
for(int j=size1-1;j>=0;j--){ //temp
flag+=(str1[j]-'0')*(str2[i]-'0');
temp.push_back('0'+(flag%10));
flag/=10;
}
if(flag) temp.push_back('0'+flag); //如果最高位还有进位
reverse(temp.begin(),temp.end());
ans=Add(ans,temp); //将计算结果累加到最终的结果上
}
if(negative) ans="-"+ans; //处理结果的正负号
return ans;
}
int main(){
cout << "请输入两个整数：" << endl;
string a, b;
cin >> a >> b;
string result = Mul(a, b);
cout << "积：" << result << endl;
return 0;
}
6. División de números enteros grandes, el resultado del cálculo tiene una precisión de 6 decimales (descarte directamente después de 6 decimales)
Como por ejemplo negocio 3.700014[5800933124]
La implementación de la división de números grandes también se calcula utilizando nuestro método de fórmula de división. Primero, utilice el método XOR para determinar el signo del resultado. Al dividir dos números, si el primer número es mayor o igual que el segundo, el resultado debe ser mayor o igual a 1, en caso contrario es menor que 1. Por lo tanto, para lograr una representación del resultado menor que 1, hacemos que el resultado tenga una precisión de 6 decimales. El método utilizado aquí es: determine de antemano si es un decimal puro, luego agregue 6 ceros al final del primer número y luego use nuestro método de fórmula de división para calcular. Comenzando desde la cabeza del primer número, busque el primer número cuya longitud pueda usarse para el cálculo del cociente, calcule el cociente y agregue un dígito al resto temporal para calcular el siguiente cociente hasta que se complete el cálculo.
En la división, es posible que te encuentres con una situación en la que el divisor sea 0, por lo que debes tomar una decisión con anticipación durante el cálculo. Además, durante el proceso de cálculo, el método de cálculo del cociente utiliza la operación de resta de números grandes, por lo que puede encontrarse con la situación de acumulación 0 (mayor longitud), lo que afectará la comparación y determinación del tamaño, por lo que deberá pagar atención al manejo.
Finalmente, consideramos algunos casos especiales, por ejemplo, cuando el dividendo es 0, el resultado 0,000000 se puede generar directamente.
implementar código
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//判断两个超大正整数的大小
bool Lower(string str1, string str2){
//长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
return str1.size()<str2.size()||(str1.size()==str2.size()&&str1<str2);
}
//判断是否为负，只需要判断第一位是不是负号即可，这里不考虑正号的存在，即认为不使用正号
bool CheckNegative(const string &str){ //检查是否为负数
return str[0]=='-';
}
//判断是否为0，全部为0的数字就是0，比如00000
bool CheckZero(const string &str){ //检查是否等于0
int size=str.size(); //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
for(int i=0;i<size;i++)
if(str[i]!='0') return false;
return true;
}
//大数减法
string Sub(string str1, string str2){
//处理0的情况
if(str1==str2||(CheckZero(str1)&&CheckZero(str2))) return "0"; //如果两数相等或者都是0
else if(CheckZero(str1)) return "-"+str2; //如果第一个数字为0
else if(CheckZero(str2)) return str1; //如果第二个数字为0
//定正负
int negative=0; //结果的正负号
if(Lower(str1,str2)){
swap(str1,str2); //保证str1大于str2
negative=1; //如果str1小于str2，则结果过为负值
}
string ans;
int i=str1.size()-1,j=str2.size()-1;//逆序开始处理
int flag=0; //借位标记
while(i>=0||j>=0){
int numa=i>=0?str1[i--]-'0':0; //取每一位，因为长度可能不同所以当某一个已经读取完毕时对应位置取0
int numb=j>=0?str2[j--]-'0':0;
numa-=flag; //先减去借位
if(numa<numb){ //如果不够减则向上一位借位（只可能借一位）
numa+=10; //借位并记录借位
flag=1;
}
else flag=0; //如果不借位，则借位标记为0
ans+='0'+numa-numb; //计算当前位置并保存
}
i=ans.size()-1;
while(ans[i]=='0') i--;
ans=ans.substr(0,i+1); //去除前导0,如111-110=1
if(negative) ans+='-'; //如果计算结果是负数，添加负数符号
reverse(ans.begin(),ans.end()); //因为是逆序计算得到的结果，所以需要翻转一下
return ans;
}
string Div(string str1, string str2){
//处理除数为0的情况和被除数为0的情况
if(CheckZero(str2)) return "The divisor cannot be zero!";
else if(CheckZero(str1)) return "0.000000";
int negative=0,negastr1=0,negastr2=0; //定正负
if(CheckNegative(str1)){ //确定正负号标记，并且去掉-
negastr1=1; str1=str1.substr(1,str1.size()-1);
}
if(CheckNegative(str2)){
negastr2=1; str2=str2.substr(1,str2.size()-1);
}
negative=negastr1^negastr2; //异或运算确定结果的正负号
int point=0; //结果是否为纯小数
if(Lower(str1,str2)) point=1; //如果str1小于str2，则计算为纯小数
string ans; //计算结果
str1+=string(6,'0'); //补足6个0，用于计算小数位
int size1=str1.size(),size2=str2.size();
int i=size2-1; //商第一位的位置
string temp=str1.substr(0,i); //从str1上取size2-1个字符
for(i;i<size1;i++){
temp+=str1[i]; //从后边拿出一位，预先处理可以防止结尾处越界
int cnt=0; //当前位的商，也就是temp中包含了多少个str2，使用减法 //如果temp不为0，则计算商
while(Lower(str2,temp)||temp==str2){ //如果当前位商不为0，则计算商
temp=Sub(temp,str2);
cnt++;
}
if(temp=="0") temp.clear(); //如果某次计算结果为0，则清空，避免0的堆积,比如111000 111
ans.push_back('0'+cnt); //保存商
}
i=0;
while(ans[i]=='0') i++;
ans=ans.substr(i,ans.size()-i); //去除前导0
if(point){ //如果是纯小数,补足6位并添加小数点
int len=6-ans.size();
ans="0."+string(len,'0')+ans;
}
else ans.insert((ans.end()-6),'.'); //如果不是小数，则只需要插入小数点
if(negative) ans="-"+ans; //最后一步骤，如果是负数带上负号
return ans;
}
int main(){
cout << "请输入两个整数：" << endl;
string a, b;
cin >> a >> b;
string result = Div(a, b);
cout << "商(6位小数后直接舍去)：" << result << endl;
return 0;
}
7. Finalmente, integra en las cuatro operaciones aritméticas de números grandes.
Las operaciones de suma y resta se limitan a operaciones de números enteros no negativos, porque las operaciones de suma y resta de números negativos pueden ser equivalentes a alguna forma de operaciones de suma o resta, por lo que no se consideran; las operaciones de multiplicación y división solo consideran operaciones de números enteros grandes. no cálculos decimales; división Solo se consideran operaciones con números enteros grandes y los resultados del cálculo tienen una precisión de 6 decimales (descartando directamente después de 6 decimales). El código fuente es el siguiente:
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//大数四则运算，两个参数都不能为空
string Add(string str1, string str2); //大数加法
string Sub(string str1, string str2); //大数减法
string Mul(string str1, string str2); //大数乘法
string Div(string str1, string str2); //大数除法
bool Lower(string str1, string str2); //大数比较（小于）
bool CheckZero(const string &str); //检查是不是0，比如0000认为是0
bool CheckNegative(const string &str); //检查是不是负数
void ShowMenu(); //提示菜单
void ShowMenu(char choice); //二级菜单
int main(){
string a,b;
char ch;
ShowMenu();
while(cin>>ch&&ch!='q'){ //循环打印菜单并提示用户输入
ShowMenu(ch);
cin>>a>>b;
switch(ch){
case 'a':cout<<a<<" + "<<b<<" = "<<Add(a,b)<<endl;break;
case 'b':cout<<a<<" - "<<b<<" = "<<Sub(a,b)<<endl;break;
case 'c':cout<<a<<" * "<<b<<" = "<<Mul(a,b)<<endl;break;
case 'd':cout<<a<<" / "<<b<<" = "<<Div(a,b)<<endl;break;
}
ShowMenu();
}
return 0;
}
string Add(string str1, string str2){
//关于0的处理
if(CheckZero(str1)&&CheckZero(str2)) return "0"; //如果都是0
else if(CheckZero(str1)) return str2; //如果有个一为0
else if(CheckZero(str2)) return str1;
string ans;
int i=str1.size()-1,j=str2.size()-1;
int flag=0; //进位标记
while(i>=0||j>=0||flag){
int numa=i>=0?str1[i--]-'0':0; //如果所有位都访问完毕，对应的位置用0代替
int numb=j>=0?str2[j--]-'0':0;
flag=numa+numb+flag; //计算两位的和
ans+='0'+flag%10; //取个位保存在答案中
flag/=10; //计算进位
}
reverse(ans.begin(),ans.end());
return ans;
}
string Sub(string str1, string str2){
//处理0的情况
if(str1==str2||(CheckZero(str1)&&CheckZero(str2))) return "0"; //如果两数相等或者都是0
else if(CheckZero(str1)) return "-"+str2; //如果第一个数字为0
else if(CheckZero(str2)) return str1; //如果第二个数字为0
//定正负
int negative=0; //结果的正负号
if(Lower(str1,str2)){
swap(str1,str2); //保证str1大于str2
negative=1; //如果str1小于str2，则结果过为负值
}
string ans;
int i=str1.size()-1,j=str2.size()-1;//逆序开始处理
int flag=0; //借位标记
while(i>=0||j>=0){
int numa=i>=0?str1[i--]-'0':0; //取每一位，因为长度可能不同所以当某一个已经读取完毕时对应位置取0
int numb=j>=0?str2[j--]-'0':0;
numa-=flag; //先减去借位
if(numa<numb){ //如果不够减则向上一位借位（只可能借一位）
numa+=10; //借位并记录借位
flag=1;
}
else flag=0; //如果不借位，则借位标记为0
ans+='0'+numa-numb; //计算当前位置并保存
}
i=ans.size()-1;
while(ans[i]=='0') i--;
ans=ans.substr(0,i+1); //去除前导0,如111-110=1
if(negative) ans+='-'; //如果计算结果是负数，添加负数符号
reverse(ans.begin(),ans.end()); //因为是逆序计算得到的结果，所以需要翻转一下
return ans;
}
string Mul(string str1, string str2){
if(CheckZero(str1)||CheckZero(str2)) return "0"; //如果有一个为0,则结果为0
int negative=0,negastr1=0,negastr2=0; //定正负
if(CheckNegative(str1)){ //确定正负号标记，并且去掉-字符
negastr1=1; str1=str1.substr(1,str1.size()-1);
}
if(CheckNegative(str2)){
negastr2=1; str2=str2.substr(1,str2.size()-1);
}
negative=negastr1^negastr2; //异或运算确定结果的正负号
string ans;
if(Lower(str1,str2)) swap(str1,str2); //保证str1大于等于str2
int size1=str1.size(),size2=str2.size();
for(int i=size2-1;i>=0;i--){ //遍历较小数字的每一位
string temp(size2-1-i,'0'); //temp为str1乘以str2[i]的积，根据str2[i]的权重（个十百千万，补充对应个数的0）
int flag=0; //进位标记
for(int j=size1-1;j>=0;j--){ //temp
flag+=(str1[j]-'0')*(str2[i]-'0');
temp.push_back('0'+(flag%10));
flag/=10;
}
if(flag) temp.push_back('0'+flag); //如果最高位还有进位
reverse(temp.begin(),temp.end());
ans=Add(ans,temp); //将计算结果累加到最终的结果上
}
if(negative) ans="-"+ans; //处理结果的正负号
return ans;
}
string Div(string str1, string str2){
//处理除数为0的情况和被除数为0的情况
if(CheckZero(str2)) return "The divisor cannot be zero!";
else if(CheckZero(str1)) return "0.000000";
int negative=0,negastr1=0,negastr2=0; //定正负
if(CheckNegative(str1)){ //确定正负号标记，并且去掉-
negastr1=1; str1=str1.substr(1,str1.size()-1);
}
if(CheckNegative(str2)){
negastr2=1; str2=str2.substr(1,str2.size()-1);
}
negative=negastr1^negastr2; //异或运算确定结果的正负号
int point=0; //结果是否为纯小数
if(Lower(str1,str2)) point=1; //如果str1小于str2，则计算为纯小数
string ans; //计算结果
str1+=string(6,'0'); //补足6个0，用于计算小数位
int size1=str1.size(),size2=str2.size();
int i=size2-1; //商第一位的位置
string temp=str1.substr(0,i); //从str1上取size2-1个字符
for(i;i<size1;i++){
temp+=str1[i]; //从后边拿出一位，预先处理可以防止结尾处越界
int cnt=0; //当前位的商，也就是temp中包含了多少个str2，使用减法 //如果temp不为0，则计算商
while(Lower(str2,temp)||temp==str2){ //如果当前位商不为0，则计算商
temp=Sub(temp,str2);
cnt++;
}
if(temp=="0") temp.clear(); //如果某次计算结果为0，则清空，避免0的堆积,比如111000 111
ans.push_back('0'+cnt); //保存商
}
i=0;
while(ans[i]=='0') i++;
ans=ans.substr(i,ans.size()-i); //去除前导0
if(point){ //如果是纯小数,补足6位并添加小数点
int len=6-ans.size();
ans="0."+string(len,'0')+ans;
}
else ans.insert((ans.end()-6),'.'); //如果不是小数，则只需要插入小数点
if(negative) ans="-"+ans; //最后一步骤，如果是负数带上负号
return ans;
}
bool Lower(string str1, string str2){ //长度长的一定大（这里假设除了0以外，都没有前导0），长度相等则字典序小的数字更小
return str1.size()<str2.size()||(str1.size()==str2.size()&&str1<str2);
}
bool CheckZero(const string &str){ //检查是否等于0
int size=str.size(); //如果全是0则为0，这里假设不会有带符号的+00000或者-00000作为输入
for(int i=0;i<size;i++)
if(str[i]!='0') return false;
return true;
}
bool CheckNegative(const string &str){ //检查是否为负数
return str[0]=='-';
}
void ShowMenu(){
cout<<"请选择要进行的大数运算：\n"
<<"a) 加法 b) 减法\n"
<<"c) 乘法 d) 除法\n"
<<"q) 退出\n"
<<"请输入你的选择： ";
}
void ShowMenu(char choice){
cout<<"请输入要计算的两个数字";
switch(choice){
case 'a':cout<<"（仅支持非负整数加法计算）: "<<endl;break;
case 'b':cout<<"（仅支持非负整数减法计算）: "<<endl;break;
case 'c':cout<<"（仅支持整数乘法计算）: "<<endl;break;
case 'd':cout<<"（仅支持整数除法计算，计算结果保留6位小数，之后的直接舍弃）: "<<endl;break;
}
}
Apéndice, estudio y comprensión adicionales
https://blog.csdn.net/weixin_44668898/article/details/96763177