Código fuente del programa de cepillado proxy
//////////////////////////////////////////// // ///////////////////////////////////////////////// ////// ///////////////////////////////////////////// //////////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.
//////////////////////////////////////////// // ///////////////////////////////////////////////// ////// /////////////////////////////////////
# incluir ltiostream gt
# incluir lt string gt
Usar espacio de nombres std
categoría persona importante {
Cadena num1, num2
Resultado de cadena;
int precision;
Operación de carga
Pública:
bigshot(){
num 1 = num 2 = " 0 ";
resultado = " 0
precisión = 5;
}
Cuerda de suma de acordes.plus(amplificador de cuerda, amplificador de cuerda);
cadena y resta (amplificador de cuerda, cuerda)
cadena y amplificador de cuerda. amp);
División de acordes y cuerdas (amplificador de cuerdas, amplificador de cuerdas)
void show()
interfaz de figura grande vacía();
p>
Cuerdas y hilos.
revese(String amp);
Equipo de amigos amp operator gt gt(istream amp i,big man ampa){
return i gt gta .num 1 gta .operator gt gta; .num 2;
}
~BigFigure(){ }
};
void BigFigure::show(){
cout lt ltresult: " lt ltresult lt ltendl
}
void big figure::big figure interface(){
Big shot a;
cout lt lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */n";
cout lt lt"Bienvenido.../n ";
cout lt lt"Cuatro grandes números Operación/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, O es el operador (por ejemplo, entrada: 123456789/432432). /n ";
cout lt lt"3 Como 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'){
Interruptor (operación){
Caso ' ': a.plus(a.num1, a.num 2);
a .show(); break;
Caso '-': a.minus(a.num1, a.num2);
a.show(); >
caso '*': a.Multiplicación(a.num1, a.num2);
a.show();
caso '/': a . division(a . num 1, a . num 2);
a . show();
Valor predeterminado: cout lt lta . operación aritmética.
/n ";
}
cout lt lt"[figura grande #]";
CIN gt; gta;
}
System("cls");
cout lt lt"/n/n/n/n/n/n/t/tExit.../n/n/ n /n/n/n/n ";
Sistema("pausa");
}
Cadena a cadena. revese(Amplificadores de cuerda) {
char c;
int t = s tamaño();
for(int I = 0; iltt/2;i){
c = s[I];
s[I]= s[t-I-1];
s[t-I-1]= c;
p>
}
Return s;
}
Acorde y cadena BigFigure::plus(String ampstr1, String sum. Str2) { //Operación de suma, símbolos sin procesar
int min=0, I, t = 0;
Temperatura de cadena;
resultado clear( ); p>
cadena 1 = revese(cadena 1);
cadena 2 = revese(cadena 2);
min = cadena tamaño() lt; ()? str 1 . tamaño(): str 2 . [I]-96t) 10 48
t = (cadena 1[I]cadena 2[I]-96t)/10; p>if(min==str1.size()){
mientras(iltstr2.size()){
temp =(str 2[I ] t-48) 10 48;
t = (cadena 2[I]-48 t)/10
i
}
si( t)temp = ' 1 ';
}
else{
mientras(i ltstr1.size()){
temp =(cadena 1[I] t-48) 10 48;
t =(cadena 1[I]-48 t)/10;
i ;
}
if(t)temp = ' 1 ';
}
resultado = revese(temp);
p>Devolver resultados;
}
Cadenas y cadenas. Resta(String ampstr1, String sum. 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() amp; ampstr 1. compare(cadena 2)== 1){< / p>
cadena 1 = revese(cadena 1);
cadena 2 = revese(cadena 2);
bandera = 0;
min =; str 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 ) ;
bandera = 1;
min = cadena 2 .
}
temp . /p>
for(I = 0;iltmini){
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
}
}
while(iltstr1.size()){
si (!t){
while(iltstr1.size()){
temp = str 1[ Yo];
i ;
}
Romper
}
if( str1[i] ! = ' 0 '){ temp = str 1[I]-t = 0;
else temp = ' 9 '; >}
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];< / p>
Pausa;
}
}
if(flag)s = '-' s;
Resultado = s;
devolver resultado
Fruta;
}
Cuerda y cordel. Multiplicación (String ampstr1, String sum. 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]= = '-'){ flag; str1.erase(0, 1);}
if(str 2[0]= = '-'){ flag; str2.erase(0, 1);}
str 1 = revese(str 1);
str 2 = revese(str 2);
for(unsigned int I = 0; i ltstr 2 . size(); i ){
c = " 0";
for(unsigned int j = 0; j ltstr 1 . size(); j ){
temp 1 =((str 2[I]-48) *(str 1[ j]-48) c-48) 10 48;
c =((str 2[I]-48)*(str 1[j]-48) c-48) /10 48;
}
Si (c!= ' 0 ')temp 1 = c;
temp 1 = revese(temp 1);
for(int k = 0; k lt i; k )
temp 1 = "0"
temp2=plus(temp1, temp 2
<); p>temp 1 . clear();}
si (bandera 2) temp 2 = '-' temp 2
resultado = temp2
Devolver resultado;
}
Acorde y cuerda. división (cadena 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 ltstr 1. size(); I){//Procesamiento separable
cadena = 0;
temp = cadena 1[I];
if(temp[0]=='0') temp.erase( 0, 1 );
if(temp . size() gt; str2.size() ||
(temp . size()= = str 2 . size() amp ; amptemp. comparar(str2)>=0)){
mientras(temp . size() gt; str2.size() ||
(temp . size()= = str 2 tamaño() amp; amptemp.compare(str2)>=0)){
tempt = str2
temp = resta (temp, tent);
str;
}
temps = str 48;
}
si no(temp . size()= = str 2 . tamaño() amp; amptemp . compare(str 2)== 0)temps = ' 1 '
else temps = "0"; p>bandera 1 = temps . tamaño();
if(temp!= " 0 " amp ampprecision) temps = ' ';
for(int I = 0;IltPrecision 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() amp; amptemp.compare(str2)>=0)){
while(temp . size() gt; str2.size() ||
(temp . size()= = str 2 . size() amp; amptemp.compare(str2)> =0) ){
tempt = str2
temp =resta(temp,tempt);
str;
}
p >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; /p>
if(temps[temps . size()-1] gt; = ' 5 ' amp ampflag 2-flag 1 = = precisión){//Procesamiento de redondeo.
temps.erase(flag1, 1);
temps . erase(temps . size()-1, 1);
temp = " 1 "; ;
temps=plus(temps, temp);
if(temps . size() gt;' bandera 2)temps .insert(bandera 1 1, 1, '.' );
else temps.insert(bandera1, 1, '.');
}
else if(bandera 2-bandera 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 a la izquierda
if(temps[k]!='0' || temps[k 1]== ','){
for (int n = k; n lttemps . size(); n )
temp = temps[n];
Pausa;
}
}
if (bandera 2) temp = '-' temp;
resultado = temperatura
devuelve resultado; >}
Int main(){// función principal
Figura grande a;
a.interfaz de figura grande();
Devuelve 0;