Programación de rito
# include & ltlist& gt
# include & ltstring& gt
# include & ltiomanip & gt
Usar espacio de nombres estándar
Clase BigIntAdd
{
Público:
Equipo de amigos y operadores & gt& gt(istream & in, BigIntAdd & amp
Amigo de Oyster y operador de amplificador & lt& lt(ostream & ampout, const BigIntAdd & amp
operador amigo de BigIntAdd + (BigIntAdd & amp; sumando 1. sumando 2
);Privado:
//Declarar un objeto de tabla para almacenar números enteros.
Lista& ltshort int & gtmyInt
};
//Función de entrada de enteros
istream & amp operator& gt& gt( istream &at, BigIntAdd&number)
{
String str
at>& gtstr//Utilice cadena para almacenar números enteros
size_t len = str length. ();
size_t q, r, first
//si nodos correspondientes al símbolo de construcción y nodos con dígitos menores a tres.
if(is digit(str[0])//El número sin firmar correspondiente.
{
//Crea un nodo firmado del número sin firmar, trate los números sin signo como números positivos
número Myint push _ back(1);// Grupo, si r==0, determine q grupos. nodos.
//Si r! =0, determina q+1 nodos
r. = len % 3;
primero = r;
if(r!=0)
{
int nodeValue(0) ;
size_t I = 0;
for(;i<= r-1;i++)
nodeValue = 10 * nodeValue+(str[ I]--0 ');
//Tenga en cuenta que la expresión aquí corresponde al valor del nodo de r! =0
number . >Else //El número firmado correspondiente
{
//Usar el número firmado crea un nodo firmado
if(str[0]=='-' )
número . push _ back(-1);
Otros
número .
//El número firmado aquí debe procesarse desde el segundo elemento.
q =(len-1)/3;
r =(len-1)% 3;
primero = r+1;
if(r!=0)
{
int nodeValue(0);
tamaño _ t I = 1;
for(i<=r;i++)
nodeValue = 10 * nodeValue+(str[I]--0 ');
número Myint . );
}
}
//bucle for//corresponde al nodo con números completos.
for(size _ t j = 0; j & ltq; j++)
{
int nodeValue(0);
/ / Hay tres bits a la vez, lo que supone un incremento de un nodo.
size_t index = primero+3 * j;
for(int I = 0;i<=2;i++)
nodeValue = 10 * nodeValue+(str [índice+I]--0 ');
número . Myint . push _ back(nodeValue);
}
Retorno;
}
//Función de salida de enteros
Oyster&;operator<<(ostream&out, const BigIntAdd&number)
{
List & ltshort int & gt* const _ iterator ITER = número . Myint . start();
//Apunta al nodo del símbolo
if(*iter==-1)
out & lt& lt'-';//Si es un número negativo, genera "--", si es un número positivo, no se generará ningún símbolo.
if(++iter==number.myInt.end())
out & lt& lt0;//El número correspondiente es cero
Else / / Genera el número correspondiente a cada nodo.
{
out & lt& lt* iter
for(iter++; iter!= número . Myint . end(); ++iter)
out & lt& ltSecretaria de Medio Ambiente, Transportes y Obras (3)
& lt& ltset fill(“0”)
& lt& lt* iter
}
Salido;
}
//Función de suma de enteros
Operador BigIntAdd + (BigIntAdd & amp; add1, BigIntAdd & ampadd2)
{
//Obtener el signo de dos números
Lista & ltshort int & gt* iterador ITER 1 = agregar 1 Myint. ();
Lista & ltshort int & gt * iterador ITER 2 = agregar 2
Sign1=*iter1, sign2 = * iter2
Símbolo de suma corta; //Guardar el símbolo de resultado
size _ t SZ 1 = add 1 . Myint . >
size _ t sz2 = add 2 . Myint . size()-1; //El número de nodos en la parte numérica de add2
//Determina el signo del resultado de la operación.
if(signo 1 * signo 2 & gt; 0) //Los dos números tienen el mismo signo.
{
if(signo 1 =-1)//Ambos números son negativos.
{
sumSign =-1
signo 1 = 1;
signo 2 = 1; >}
Else //Ambos números son positivos.
sumSign = 1;
}
Else //Los dos números tienen signos diferentes.
if(signo 1 * signo 2 & lt; 0)
If(sz1==sz2) //Dos dígitos son iguales.
{
//Comience desde el primer nodo numérico, es decir, el bit más alto
for(iter1++, ITER 2++; iter1!= add 1. Myint . end(); iter1++, iter2++)
{
if(* ITER 1 * signo 1+* ITER 2 * signo 2 < 0)//El absoluto de números negativos Gran valor.
{
sumSign =-1;
signo 1 =-signo 1;
signo 2 =-signo 2;
p>
p>
Romper;
}
if((* ITER 1 * signo 1)+(* ITER 2 * signo 2)>0)/ /Número positivo absoluto Gran valor.
{
sumSign = 1
Romper
}
}
if (ITER 1 == plus 1. Myint. end()) // Los valores absolutos son iguales.
sumSign = 1;
}
Else //Los dos dígitos no son iguales.
if(SZ 1 * sign 1+sz2 * sign 2 <0)//Hay muchos dígitos negativos.
{
sumSign =-1;
signo 1 =-signo 1;
signo 2 =-signo 2;
p>
p>
}
De lo contrario //Los números positivos tienen muchos dígitos.
sumSign = 1;
//Determina la parte numérica del resultado de la operación.
Lista & ltshort int & gt::reverse _ iterador riter 1 = agregar 1 . Myint Rb begin();
Lista & ltshort int & gt* inverso _ iterador riter 2. = agregar 2 . Myint . Rb comenzar();
//Definir dos iteradores inversos.
BigIntAdd suma//Resultados de la operación de almacenamiento.
Short carry = 0; // Valor de transporte de almacenamiento
// La parte de suma correspondiente a los dos números no es cero.
while(riter1!=-add 1 . Myint . rend()& & ampriter2 != - add2.myInt.rend())
{
short temp =(* riter 1 * sign 1)+(* riter 2 * sign 2)+carry;
if(temp <0) //El valor de la operación es negativo.
{
temp+= short(1000);
Carry=-1;
}
Si no //El valor de la operación es positivo.
{
Llevar = temp/short(1000
temp % = 1000
}
riter 1++
riter 2++; >//La parte de suma correspondiente de //add2 es cero.
while(riter1!= - add1.myInt.rend())
{
temperatura corta = * riter 1+carry;
if(temp & lt; 0) //El valor de la operación es negativo.
{
temp+= short(1000);
Carry=-1;
}
Si no //El valor de la operación es positivo.
{
Acarreo = temp/1000;
temp % = 1000
}
suma. Myint . push _ front(temp);
riter 1++;
}
//add1 corresponde a la suma cero.
while(riter2!= - add2.myInt.rend())
{
temperatura corta = * riter 2+carry;
if(temp & lt; 0) //El valor de la operación es negativo.
{
temp+= short(1000);
Carry=-1;
}
Si no //El valor de la operación es positivo.
{
Acarreo = temp/1000;
temp % = 1000
}
suma. Myint . push _ front(temp);
riter 2++;
}
If (carry!=0) //La última operación del nodo correspondiente El resultado es un acarreo.
sum.myInt.push_front(carry);
while(*sum.myInt.begin()==0)
sum pop _. front();
//Cuando el nodo correspondiente al bit más alto no tiene un valor válido, elimina el nodo.
sum . Myint . push _ front(sumSign);
//Agrega el símbolo del resultado de la operación a la lista vinculada de resultados.
Devolver la suma;
}