Programación interna de multiplicaciones
//?BigInteger.h? Incluyendo la definición de estructura de nodo y la definición de clase BigInteger.
//?BigInteger.cpp? Contiene el contenido específico de las funciones miembro de la clase BigInteger.
//?main.cpp? Funciones principales...
/*************************************** ***** **********************/
//BigInteger.h
estructura? Nodo//Definir la estructura del nodo.
{
¿Ciel? Núm
¿Nodo? *Anterior, *Siguiente
};
¿Clase? BigInteger//¿Definir BigInteger? Tipo
{
¿Nodo? *Cabeza, *Fin, * TempNode
¿No es válido? AddHead(char?num);
¿No es válido? Addend(char?num);
Público:
entero grande();
BigInteger(const?BigInteger? ampBigNum);
¿No válido? obtener número();
¿No es válido? disp();
¿GranInteger? ¿operador? ?(const?BigInteger? ampBigNum);
BigInteger? ¿operador? *?(const?BigInteger? ampBigNum);
BigInteger? ¿operador? =?(const?BigInteger? ampBigNum);
~ entero grande();
};
//BigInteger.cpp
#incluir? ltiostream.h gt
#¿Contiene? ltstdio.h gt
#¿Contiene? " BigInteger.h "
BigInteger::BigInteger()//Constructor, deja cada nodo vacío.
{
Cabeza = Fin = TempNode = NULL
}
BigInteger::BigInteger(constante? ¿BigInteger? ampBigNum)? //Copiar estructura
{
¿Nodo? * p;
Encabezado = Fin = TempNode = NULL
p=BigNum. Encabezado;
while(p)
{
Suplemento.
num);
p = p- gt; siguiente;
}
}
BigInteger::~BigInteger()/ / Destructor
{
¿Nodo? * NextNode
if(Head==NULL)
Return;
TempNode = Head
mientras (nodo temporal)
{
siguiente nodo = TempNode- gt;
¿Eliminar? TempNode
TempNode = NextNode
}
Head = NULL
Fin = NULL
TempNode = NULL
}
¿Anulado? BigInteger::AddHead(char?Num)//Insertar un nodo al principio de la lista enlazada
{
TempNode=new? Nodo;
TempNode- gt; Num = Num
TempNode- gt; Prev = NULL
Si (! encabezado)
{
Head = End = TempNode
TempNode- gt; Siguiente = NULL
}
Otro
{
TempNode- gt; Siguiente = cabeza;
cabeza->; Anterior = TempNode
Cabeza = TempNode
}
}
¿No es válido? BigInteger::AddEnd(char?Num)? //Insertar un nodo al final de la lista enlazada
{
TempNode=new? Nodo;
TempNode- gt; Num = Num
TempNode- gt; Siguiente = NULL
Si (! encabezado)
{
Head = End = TempNode
TempNode- gt; Prev = NULL
}
Otro
{
TempNode- gt; Anterior = Fin
end->; Siguiente = TempNode
Fin = TempNode
}
}
¿Anulado? BigInteger::GetNumber()//Parte de entrada
{
¿Carácter? Clave;
int? count=0, num = 0;
while((key=getchar())!=10)//Determine si la entrada es un retorno de carro. Si no, coloque el contenido en la lista vinculada. de atrás hacia adelante.
{
if(key gt;='0'? amp amp?key lt='9')
{
num = clave-' 0 ';
Suma (número);
num = 0;
}
}
p>
}
¿BigInteger? BigInteger::operador? ?(const?BigInteger? ampBigNum2)//Sobrecarga " "
{
¿BigInteger? ampBigNum1=*este, resultado
nodo? *temp1, *temp2
int? TempNum, resto = 0;
temp1=BigNum1. End; //Coloque la primera dirección de la lista enlazada temporal al final de la lista enlazada de entrada.
temp2=GranNum2. fin;
mientras(temp1? amp amp? temperatura 2)
{
TempNum = int(temp 1->; num) int(temp 2- >núm) descanso;? //Agrega elementos al nodo y agrega el resto del acarreo.
if(TempNum gt; 9)//Determina si el resultado de la suma generará un acarreo.
{
NumTemp = NumTemp-10
resto = 1
}
Otros
p>
resto = 0;
resultado. AddHead(char(TempNum)); //Coloca el resultado en la lista vinculada de resultados finales.
temp 1 = temp 1->; Anterior
temp 2 = temp 2- gt; 2)temp 1 = temp 2;
mientras(temp1)
{
int(TempNum)= int(temp 1- gt;num) resto; ? //Los elementos en el nodo más el resto del acarreo
if(TempNum gt; 9)
{
TempNum = TempNum-10;
resto = 1;
}
Otro
resto = 0;
Resultado. AddHead(char(TempNum));? //Coloca el resultado en la lista vinculada de resultados finales.
temp 1 = temp 1->; Anterior
}
si(resto)
resultado. AddHead(char(rest)); // Considere si el último acarreo existe. Si existe, guárdelo al principio de la lista vinculada.
¿Volver? Resultado;
}
¿BigInteger? BigInteger::operador? *?(const?BigInteger?ampBigNum2)? //sobrecarga*.
{
¿Gran entero? ampBigNum1=*este, temperatura, resultado
¿Nodo? *temp1, *temp2, *tempa, *tempb
int? TempNum, descanso, i=0, descanso 2;
temp1=BigNum1. Fin;
temp2=BigNum2.
Fin;
Y (temp2)// Si cada dígito del multiplicando se multiplica se juzga por la presencia o ausencia del multiplicando.
{
descanso = 0
mientras(temp1!=null)
{
NumTemp = int(temp 1->num)* int(temp 2- gt;num) resto;
if(TempNum gt;9)
{?
descanso = NúmTemp/10;? //El acarreo se obtiene citando el resultado de la multiplicación y 10.
NumTemp = NumTemp 10;? // Modula el resultado de la multiplicación y 10 para obtener un bit.
}
Otros
rest = 0;
Cuando...AddHead(char(TempNum)); Lista enlazada temporal
temp 1 = temp 1->; Anterior
}
si (rest!=0) temperatura. AddHead(char(rest));
for(int?k = I;k gt=1;k -) temperatura. Suplemento(char(0));? //Determina cuántos ceros se deben agregar al final de la lista vinculada.
i; //Cuenta después de cada multiplicación, úsalo para sumar 0 la próxima vez.
temp1=GranNum1. Finalizar;? //Restablece el multiplicando hasta el final para que el multiplicador pueda multiplicar cada elemento la próxima vez.
temp 2 = temp 2- gt; Prev//Obtiene el multiplicador del anterior en la lista enlazada.
tempa=resultado. End; // Lo siguiente es acumular los resultados de la multiplicación de cada multiplicador y multiplicando y colocarlos en la lista vinculada final para su salida.
¿Si (resultado.header!=NULL)? // El siguiente proceso es básicamente el mismo que la sobrecarga " ", excepto que la lista vinculada temporal está vacía y no se realizan comentarios detallados.
{
Resultados. Fin = temperatura. Encabezado;
Resultado. Head = NULL
}
tempb = temperatura. Fin;
rest 2 = 0;
Y (tempa!=NULL? amp amp?tempb!=null)
{
TempNum = int(tempa- gt;num) int(tempb- gt;num) resto 2;
if(TempNum gt;9)
{
TempNum = TempNum-10;
descanso 2 = 1;
}
Otro
descanso 2 = 0;
Resultados. AddHead(char(TempNum));
tempa = tempa- gt;
tempb = tempb- gt
}
Blanco(tempa)
{
int(TempNum)= int(tempa- gt;num) resto 2 ;
if(TempNum gt; 9)
{
TempNum = TempNum-10;
descanso 2 = 1;
p>
}
Otro
resto 2 = 0;
Resultado.
AddHead(char(TempNum));
tempa = tempa- gt
}
if (2 restantes)
Resultado . AddHead(char(rest 2));
if (temperature.head!=null)
{
Cuando... Fin = temperatura. Cabeza;
Cabeza = NULL cuando...
}
tempb = NULL
}
Regresar ? Resultado;
}
¿BigInteger? BigInteger::operador? =?(const? BigInteger? ampBigNum) // Sobrecarga = símbolo
{
Si (esto == ampBigNum)
¿Regresar? *Este;
¿Nodo? * p;
TempNode = Encabezado = Fin = NULL
p=BigNum. Encabezado;
while(p)
{
Suplemento. num);
p = p- gt;Siguiente;
}
¿Volver? *Esto;
}
¿No es válido? BigInteger:: disp()//Lista enlazada de salida
{
If (head)
{
cout lt ltint(Head - >;num);
TempNode = Head- gt;Next;
}
¿Y si? Retorno;
mientras(nodo temporal)
{
cout lt ltint(TempNode- gt; num);
TempNode = TempNode - gt; siguiente;
}
cout lt ltendl
}
//main.cpp
#¿incluir? ltiostream.h gt
#¿Contiene? " BigInteger.h "
¿No es válido? main()
{
¿GranInteger? BigNum1, BigNum2, BigNum3
int? c;
cout lt lt"Seleccione la operación que desea realizar:"
cout lt lt"1. Operación de suma de enteros grandes"
cout lt lt " 2. Multiplicación de enteros grandes"
cout lt lt"Seleccione la operación que necesita realizar:"
CIN gtc;
Interruptor (c)
p>{
¿Caso? 1:
{?
cout lt lt"Respuesta:" lt ltendl
BigNum1. obtener número();
cout lt lt" B：" lt; ltendl
BigNum2.
get number();
bignum 3 = bignum 1 bignum 2;
cout lt lt"El resultado de la suma es: "
big num 3 . disp( );
}resuelto;
¿El caso? 2:
{
cout lt lt"Respuesta:" lt ltendl
BigNum1. obtener número();
cout lt lt" B：" lt; ltendl
BigNum2. get number();
bignum 3 = bignum 1 * bignum 2;
cout lt lt"El resultado de la multiplicación es: "
bignum 3 . disp ();
}break;
Predeterminado: break
}
}