Array de punteros a función <=> FLT_MIN - FLT_MAX [C]

[NOB2014]

Hola, gente.
Tengo un inconveniente en la validación para que no se supere el máximo y el mínimo que soporta el tipo float, en internet no encuentro nada relacionado y modifique el código muchas veces y nada, solo me deja ingresar números negativos.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <float.h>

float suma( const float o1, const float o2 );
float resta( const float o1, const float o2 );
float division( const float o1, const float o2 );
float multiplicacion( const float o1, const float o2 );


int main( void ){
float (*ptrf[]) ( float, float ) = {suma, resta, division, multiplicacion};
int ok, ch, opc;
float opeUno, opeDos, result;

printf( "\n ========== Calculadora ==========\n\n" );

do{
printf("\n Introduzca el primer operando....:");
ok = scanf("%g", &opeUno) == 1 && opeUno <= FLT_MIN && opeUno <= FLT_MAX;
while ((ch = getchar()) != EOF && ch != '\n');
}while(!ok);

do{
printf("\n Introduzca el segundo operando...:");
ok = scanf("%g", &opeDos) == 1 && opeDos <= FLT_MIN && opeDos <= FLT_MAX;
while ((ch = getchar()) != EOF && ch != '\n');
}while(!ok);

printf( "\n 1 - Suma \n 2 - Resta \n 3 - Divide \n 4 - Multiplica" );
do{
printf( "\n\n Ingrese una opcion...:" );
ok = scanf("%d", &opc) == 1 && opc >= 1 && opc <= 4;
while ((ch = getchar()) != EOF && ch != '\n');
}while(!ok);

result = ( ptrf[opc-1] ) ( opeUno, opeDos );

printf( "\n El resultado es %g", result );

return 0;
}


float suma( const float o1, const float o2 ){
return o1 + o2;
}

float resta( const float o1, const float o2 ){
return o1 - o2;
}

float division( const float o1, const float o2 ){
return o1 / o2;
}

float multiplicacion( const float o1, const float o2 ){
return o1 * o2;
}

Saludos a todos y espero puedan ayudarme a encontrar la solución.-

[HardForo]

Encuentro muy rara esta condicion:

ok = scanf("%g", &opeDos) == 1 && opeDos <= FLT_MIN && opeDos <= FLT_MAX

[NOB2014]

Hola.
Que te resulta raro, ¿no la entiendes o te parece que no puede funcionar? . -
Es lo que utilizo para validar que el ingreso no supere el mínimo y el máximo permitido por el tipo en cuestión.-

Saludos.

[HardForo]

No entiendo porque pides que sea menor o igual al maximo y menor o igual que el mínimo, en tal caso estas pidiendo que sea menor o igual al mínimo.

Si C <=A && C <=B

entonces

C<= MIN (A,B)

y si A o B son iguales al minimo absoluto del rango entonces.... estas pidiendo que ...

C = MIN_ABSOLUTO

[NOB2014]

Hola, gente.
debo reconocer que de la manera que intentaba hacer la validación es inviable, por lo tanto, lo estoy intentando con la librería atof y el máximo número que soporta es lo que muestro a continuación:

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main( void ){
double a = 9.00;
size_t i;

for( i = 1; i < 24; i++ ){
printf( "\n[%2u] ==> %f", i, a );
a *= 10.00;
}

return 0;
}


/*#include<stdio.h>
#include<stdlib.h>

int main( void ){
double a;
char buffer [256];
printf ( "\n Ingrese un numero.....: " );
gets (buffer);
a = atof (buffer);
printf ( "a = %f " , a);

return 0;
}*/


Solo necesitaría saber si en sus máquinas les da el mismo resultado.



Saludos.

[MAFUS]

Los reales float y dobule dan problemas, según su uso, pero es por su naturaleza IEEE754.
FLOAT:
   rango (aprox): 1.5e-45 a 3.4e+38
   dígitos de precisión: 7

DOUBLE:
   rango (aprox): 2.2250738585072020e−308 to 1.7976931348623157e+308
   dígitos de precisión: 15

Pásate por aquí
https://es.wikipedia.org/wiki/IEEE_coma_flotante

[HardForo]

No se te olviden las recomendaciones de @MAFUS, sin embargo haciendo caso a tu solicitud, aqui mi salida:

[ 1] ==> 9.000000
[ 2] ==> 90.000000
[ 3] ==> 900.000000
[ 4] ==> 9000.000000
[ 5] ==> 90000.000000
[ 6] ==> 900000.000000
[ 7] ==> 9000000.000000
[ 8] ==> 90000000.000000
[ 9] ==> 900000000.000000
[10] ==> 9000000000.000000
[11] ==> 90000000000.000000
[12] ==> 900000000000.000000
[13] ==> 9000000000000.000000
[14] ==> 90000000000000.000000
[15] ==> 900000000000000.000000
[16] ==> 9000000000000000.000000
[17] ==> 90000000000000000.000000
[18] ==> 900000000000000000.000000
[19] ==> 9000000000000000000.000000
[20] ==> 90000000000000000000.000000
[21] ==> 900000000000000000000.000000
[22] ==> 9000000000000000000000.000000
[23] ==> 89999999999999996000000.000000