Código fuente de suma y resta en C
//////////////////////////////////////////// // ///////////////////////////////////////////////// ////// ///////////////////////////////////////////// //////////1. El formulario de entrada es: A[espacio o carácter de nueva línea]O[espacio o carácter de nueva línea]B;
///2.1, donde A y B son números grandes y O es el operador (como entrada: 123456789/432432
//// 3. Como estamos tratando con números grandes, no es necesario ingresar decimales
//// 4. La suma y la resta no pueden manejar signos negativos, pero la multiplicación y la división sí
//// p>
//// 5. Se utiliza para; aprendizaje y comunicación. Si encuentra algún error o deficiencia, puede contactar con nosotros.
//////////////////////////////////////////// // ///////////////////////////////////////////////// ////// /////////////////////////////////////
# include & ltiostream & gt
# include & lt string& gt
Usar espacio de nombres std
Categoría persona importante {
Cadena num1, num2
Resultado de cadena;
precisión int;
Operación de carga;
Público:
Bigshot() {
núm 1 = núm 2 = " 0 ";
resultado = " 0
precisión = 5;
}
Acorde y Acorde Más(Cadena&,Cadena&);
Acorde y Acorde.Resta(Cadena&,Cadena&);
Acorde&Acorde.Multiplicación(Cadena&,Cadena&);
Chord&Chord.Division(String&,String&);
void show();
interfaz de figura grande vacía();
Cadena y cuerda.
revese(string&);
Equipo de amigos&operator>>(istream&i,bigshot&a){
return i>>a.num 1 & gt; >void BigFigure::show(){
cout & lt& ltresult:“& lt& ltresult& lt& ltendl
}
void figura grande:: interfaz de figura grande(){
Figura grande a;
cout & lt& lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */n";
cout & lt& lt"Bienvenido.../n ";
cout & lt& lt"Cuatro operaciones aritméticas en grandes números/n";
cout & lt& lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /n/n";
cout & lt& lt "Observaciones:/n";
cout & lt& lt"1. El formato de entrada es: A[espacio o carácter de nueva línea]O[espacio o carácter de nueva línea]b ./n ";
cout & lt& lt"2. En 1, A y B son números grandes y O es el operador (por ejemplo, entrada: 123456789/432432). /n ";
cout & lt& lt"3 Dado que estamos tratando con números grandes, no es necesario ingresar decimales. /n ";
cout & lt& lt" 4. La suma y la resta no pueden manejar signos negativos, pero la multiplicación y la división sí. /n ";
cout & lt& lt"5. Se utiliza para el aprendizaje y la comunicación. Si encuentra algún error, puede comunicarse con 519916178@qq.com. /n/n ";
cout & lt& lt"¡Empiece ahora! Si desea salir, ingrese 0 0 0 para finalizar. /n/n ";
cout & lt& lt"[gran figura #]";
CIN & gt;& gta;
mientras(a. operación! ='0'){
Cambiar (operación){
Caso '+': a.plus(a.num1, a.num 2);
a.show(); break;
Caso '-': a.minus(a.num1, a.num2);
a.show (); ;
case '*': a . multiplicación (a. num1, a . num 2
a . break(); '/':a . division(a . num 1, a . num 2);
a . show()
Valor predeterminado: cout & lt& lta . operación & lt& lt" no es una operación aritmética.
/n ";
}
cout & lt& lt"[gran figura #]";
CIN & gt;& gta;
}
System("cls");
cout & lt& lt"/n/n/n/n/n/n/t/tExit.../ n /n/n/n/n/n/n ";
System("pausa");
}
Cadena a cadena. revese( cadena&s ){
char c;
int t = s tamaño();
for(int I = 0; i<t/ 2; i++){
c = s[I];
s[I]= s[t-I-1];
s[t-I-1 ]= c;
}
Return s;
}
Acorde y cadena BigFigure::plus(String& ampstr1 , string sum. Str2){// Operación de suma, símbolo sin procesar
int min=0, I, t = 0;
Temperatura de cadena;
resultado clear();
cadena 1 = revese(cadena 1);
cadena 2 = revese(cadena 2
min = cadena tamaño()<str2.size(); ? str 1 .size():str 2 .size();
for(I = 0;i<mini++){
temp+=(str 1[I]+str 2[ I]-96+t)% 148;
t =(cadena 1[I]+cadena 2[I]- 96+t)/10;
}
if(min==str1.size()){
mientras(i& ltstr2.size() ){
temp+=(str 2[I] +t-48)% 148;
t =(cadena 2[I]-48+t)/10;
i++;
}
if(t)temp+= ' 1 ';
}
En caso contrario {
while(i<str1.size()){
temp+=(cadena 1[I]+t-48)% 148;
t =(cadena 1[I]-48+t)/10; p>
i++;
}
if(t)temp+= ' 1 ' ;
}
resultado = revese (temp);
Devolver resultado;
}
Acorde y cuerda. resta(String&str1,String&.Str2){ //Operación de resta, signo no controlado.
int min=0, bandera, I, t = 0
Temperatura de cadena
resultado clear(); if(cadena 1. tamaño()>;cadena 2. tamaño()| |(cadena 1. tamaño()= = cadena 2. tamaño()&&str 1. compare(cadena 2)== 1) {
cadena 1 = revese(cadena 1);
cadena 2 = revese(cadena 2);
bandera = 0
min = cadena 2; . tamaño();
}
else if(str 1 . tamaño()= = str 2 . tamaño()){
Si (!str1 .compare(str2)){
resultado = "0";
devolver resultado;
}
if(str 1 . comparar(cadena 2)= =-1){
temp = cadena 1;
cadena 1 = revese(cadena 2);
cadena 2 = revese (temp);
bandera = 1;
min = str 2 tamaño();
}
}
De lo contrario {
temp = str 1;
str 1 = revese(str 2);
str 2 = revese (temp); /p>
bandera = 1;
min = cadena 2 .
}
temp . >
for(I = 0;i & ltmini++){
if(str 1[I]-t & lt;str2[i]){
temp+= str 1[I]+10-t-str 2[I]+48;
t = 1;
}
De lo contrario {
temp+= cadena 1[I]-t-cadena 2[I]+48;
t = 0
}
}
mientras(i& ltstr1.size()){
if(!t){
mientras(i& ltstr1.size()) {
temp+= str 1[I];
i++;
}
Romper;
}
si(str1[i]! = ' 0 '){ temp+= str 1[I]-t = 0;}
else temp+= ' 9 ';
i++;
}
Cadena s;
for(unsigned int k = temp . size()-1; k & gt=0;k - ){
if(temp[k]!='0'){
for(int n = k; n & gt=0;n -)
s+= temp[n] ;
Descanso;
}
}
if(flag)s = '-'+s;
Resultado = s;
Devuelve resultado;
}
Cadena y cadena. Multiplicar (String&str1, StringSum.
Str2){//Operación de multiplicación, símbolos procesados
char c='0 ', flag = 0;
string temp1, temp2 = " 0
if (cadena 1[0]= = ' 0 ' | | cadena 2[0]= = ' 0 '){
resultado = " 0
Devolver resultado;
}
if(str 1[0]= = '-'){ bandera++; str1.erase(0, 1);}
if(str 2[ 0 ]= = '-'){ flag++; str2.erase(0, 1);}
cadena 1 = revese(cadena 1);
cadena 2 = revese(cadena 2) );
for(unsigned int I = 0; i<str 2. size(); i++){
c = "0";
for(unsigned int j = 0; j & ltstr 1 . -48)% 148;
c =((cadena 2[I]-48)*(cadena 1[j]-48)+c-48)/1 48;
}
if (c!= ' 0 ')temp 1+= c;
temp 1 = revese(temp 1);
p>
for(int k = 0; k & lt i; k++)
temp 1+="0";
temp2=plus(temp1, temp 2) ;
temp 1 . clear();
}
si (marca % 2)temp 2 = '-'+temp 2;
Resultado = temp2
Devuelve resultado;
}
Cadena y cadena. división (cadena y ampstr1, suma de cadena.
Str2){//Operación de división, símbolos procesados
int str=0, flag=0, flag1=0, flag 2 = 0;
String temp, temps, tempt
if(str2=="0"){
resultado = " Inf
Devuelve el resultado;
}
if(str 2 == " 1 " | | str 1 == " 0 "){
resultado = str 1;
devolver resultado;
}
if(str 1[0]= = '-'){ bandera++; str1.erase(0, 1);}
if(str 2[0] = = '-'){ flag++;str2.erase(0, 1);}
for(unsigned int I = 0;i<str 1.size();I++){//can Subprocesamiento
cadena = 0;
temp+= cadena 1[I];
if(temp[0]=='0') temp.erase (0, 1);
if(temp . size()> str2.size() ||
(temp . size()= = str 2 . size()&&temp .compare(str2)>=0)){
mientras(temp . tamaño()& gt;str2.size() ||
(temp . tamaño()= = str 2 . tamaño()& & temp.compare(str2)>=0)){
tempt = str2
temp =resta(temp ,tempt);
str++;
}
temps+= str+48;
}
else if(temp . size()= = str 2 . p>
bandera 1 = temps tamaño();
if(temp!= " 0 " & amp& ampprecision) temps+= ' . = 0;I<Precisión y Matemáticas.
¡Y trabajadores temporales! ="0";I++){//Postprocesamiento decimal
str = 0
temp+="0"
if(temp . size(); & gt; str2.size() ||
(temp . size()= = str 2 . size()& & temp.compare(str2)>=0)){
while(temp . size()& gt; str2.size() ||
(temp . size()= = str 2 . size()& & amptemp .compare(str2)>= 0)){
tempt = str2
temp =resta(temp,tempt);
str++;
}
temps+= str+48;
}
else if(temp . size()= = str 2 . size()& amp ;& amptemp . compare(str 2)= = 0)temps+= ' 1 ';
else temps+= "0";
}
flag 2 = temps()-. 2;
if(temps[temps . size()-1]& gt;= ' 5 ' & amp& ampflag 2-flag 1 = = precisión){//truncar en procesamiento.
temps.erase(flag1, 1);
temps . erase(temps . size()-1, 1);
temp = " 1 "; ;
temps=plus(temps, temp);
if(temps . size()>' bandera 2)temps .insertar(bandera 1+1, 1,' . ');
else temps.insert(flag1, 1, '.');
}
else if(flag 2-flag 1 = = precisión )temps . erase(temps . size()-1, 1);
temp clear()
for (entero sin signo k = 0; k & lttemps . size( ); K++){//procesamiento de puesta a cero del lado izquierdo
if(temps[k]!='0' || temps[k+1]== ','){
for(int n = k; n & lttemps . size(); n++)
temp+= temps[n];
Descanso;
}
}
if (bandera % 2) temp = '-'+temp;
resultado = temperatura
devuelve resultado;
}
Int main(){// función principal
Figura grande a;
a.interfaz de figura grande();
Devuelve 0;