Implementación del código fuente de la función ftoa
# include & ltstdio.h & gt
# include & ltmath.h & gt
//? Convierte cuatro bits binarios en caracteres de 16 bits ( Tres dígitos binarios se convierten en dígitos octales) (el decimal 0-9 se convierte en un carácter).
¿Ciel? FourBinaryToOneHexadecimalChar(¿Sin firmar? ¿Carácter? Número)
{
¿Cambiar? (número)
{
¿Caso? 0:?Regresar? '0';
¿Caso? 1:?¿Regresar? '1';
¿Caso? 2:?Regreso? '2';
¿Caso? 3:?Regresar? '3';
¿Caso? 4:?Regreso? '4';
¿Caso? 5:?Regreso? '5';
¿Caso? 6:?¿Regresar? '6';
¿Caso? 7:?Regresar? '7';
¿Caso? 8:?¿Regresar? '8';
¿Caso? 9:?¿Regresar? '9';
¿Caso? 10:?Regreso? un’;
¿Caso? 11:?¿Regresar? b’;
¿Caso? 12:?Regreso? c’;
¿Caso? 13:?Regreso? d’;
¿Caso? 14:?Regreso? e’;
¿Caso? 15:?¿Regreso? f';
Predeterminado:? ¿devolver? x’;
}
}
//?Inversión de cadena
¿No es válido? límite inverso(char?*source,?int?start,?int?end)
{
int? Yo;
¿Ciel? Temperatura;
¿Para qué? (I?=?0;?I?<?((¿Fin?-?Inicio?+?1)?/?2);?++i)
{
¿Trabajadores temporales? =?Fuente【¿Iniciar? +?I];
Fuente [¿Inicio? +?Yo]? =?Fuente【Fin? -?I];
Fuente [Fin? -?I]? =?Temperatura;
}
}
//?Comparar tamaños de tipografía flotante
int? CompareFloat(¿flotador? ¿uno? ¿flotador? b)
{
¿Si? ((A?& lt?b)
& amp& amp?(fabs(A?-?b)?& gt?1e-6f))
{
¿Regresar? -1;
}
¿Y si? ¿si? ((A?& gt?b)
& amp& amp?(fabs(A?-?b)?& gt?1e-6f))
{
¿Regresar? 1;
}
Otros
{
¿Volver? 0;
}
}
//? Punto flotante a cadena (decimal) (la precisión es precisión decimal)
¿No es válido? floattostringdecimal(float?float,?char?*destination,?unsigned?int?precision)
{
si? (CompareFloat(Float,?0)?!=?0)
{
//?Mover el lugar decimal al lugar entero
¿Flotador? ¿Trabajador temporal? =?¿Flotar? *?powf(10.0f,? (punto flotante) precision);
//?Convierte números negativos en números positivos; de lo contrario, no se puede utilizar la conversión de rompecabezas.
¿Y si? (CompareFloat(Temp, 0)?==?-1)
{
¿Trabajadores temporales? =?-Temperatura;
}
¿Flotación? ¿IntInFloat? =?0.0;
modff(temperatura, & ampintin float);
int? ¿I? =?0;
¿No está firmado? ¿Ciel? número
¿Para qué? (i?=?0;?(i?<?(int)precisión)?&&?(CompareFloat(IntInFloat,?0)?!=?0);?++i)
{
//?¿Flotando? ¿cambiar? ¿No firmado? (Igual que organizaciones internacionales) Organizaciones internacionales
//? Transformación de rompecabezas (porque no sé cómo implementarlo internamente, por eso se llama transformación de rompecabezas)
num ? =?(Unsigned?char)((Unsigned?int)IntInFloat?%?10);
Destino[i]? =?FourBinaryToOneHexadecimalChar(num);
IntInFloat? /=?10;
modff(IntInFloat,?& ampintin float);
}
¿Si? (¿Precisión?!=?0)
{
¿Destino[i]? =?'.';
++ I;
}
¿Cuándo? (CompareFloat(IntInFloat,?0)?!=?0)
{
num? =?(Unsigned?char)((Unsigned?int)IntInFloat?%?10);
Destino[i]? =?FourBinaryToOneHexadecimalChar(num);
IntInFloat? /=?10;
modff(IntInFloat,?& ampintin float);
++ I;
}
¿Si? (CompareFloat(Float,?0)?==?-1)
{
Destino[i]? =?'-';
++ I;
}
Seguimiento inverso (destino, 0,?I?-?1);
¿Destino[i]? =?'\0';
Regreso;
}
Otros
{
Destino[ 0 ]? =?'0';
¿Destino[1]? =?'\0';
Regresar;
}
}Luego prueba.
//?Código de prueba
fprintf(FP_BaseZeroth,? "Objeto de prueba:void?flottostringdecimal(float?float,?char?*destination,?unsigned?int? Accuracy)\ n ");
fprintf(FP_BaseZeroth,?"Entrada de prueba: 0;?123;?123.456;?-123;?-123.456;?1.23456 e 10f;\n ");
fprintf(FP_BaseZeroth,?"Salida de la predicción:0;?123;?123.456;?-123;?-123.456;?Determinar la parte del dígito significativo\n");
fprintf( FP_BaseZeroth, ? "Salida real:");
¿Flotador? ¿Respuesta [6]? =?{?0.0f,? 123.0f,? 123.456f,? -123.0f,? -123.456f,? 1.23456e10f? };
¿Ciel? des[100];
flottostringdecimal(A[0],?des?0);
fprintf(FP_BaseZeroth,?" % s;?",?des);< / p>
flottostringdecimal(A[1],?des?0);
fprintf(FP_BaseZeroth,?" % s;?",?des);
floatostringdecimal( A[2],?des?3);
fprintf(FP_BaseZeroth,?"%s;?",?des);
flottostringdecimal(A[3] ,?des ?0);
fprintf(FP_BaseZeroth,?"%s;?",?des);
flottostringdecimal(A[4],?des?3 );
fprintf(FP_BaseZeroth,?" % s;?",?des);
flottostringdecimal(A[5],?des?3);
fprintf(FP_BaseZeroth ,?" % s;?",?des);
fprintf(FP_BaseZeroth,?" \ n \ n "); Resultados de la prueba