{RISOLTO}[gcc] Strani risultati (???)

[geopardy]

Ciao a tutti, sto utilizzando il gcc ma stranamente l'elaborazione di un programmino che opera con numeri in virgola mobile ha uno strano comportamento:
se in input dò dei numeri con la virgola (es 3.5 ... ) il risultato è nan (scritto proprio così)
se in input dò numeri interi, ottengo un valore che non centra niente e che viene rapresentato in notazione esponenziale (2.148873e+09)

Lo stesso sorgente, compilato con MS Quick C dà esattemente i risultati aspettati.

Credo che sbaglio qualcolsa nei parametri di compilazione, scrivo:

Codice: Seleziona tutto

gcc -lm -o mioprog mioprog.c

e la compilazione va a buon fine.
Chi mi aiuta?

[TheBestNeo]

Puoi postare il codice?

[bite]

Sparo alla cieca, senza aver visto il codice... per questa volta mi baso sulla sfera di cristallo  (rotfl)

Se usi numeri double, il formato della scanf deve essere %lf
Se usi numeri float, il formato deve essere %f

Se ci ho azzeccato dimmelo, che esco subito e vado a giocare al lotto.

[preben]

Prepara la terna, perchè, secondo me, sei sulla strada giusta.
Mi raccomando, terno secco!  (ot)

[geopardy]

Si giusto.... (questo mi fa capire che non è un problema molto comune)
Il codice, per chi ha  letto il testo Kernighan Ritchie è l'esempio sulle variabile esterne del capitolo 4: calcolatrice in notazione polacca inversa

Codice: Seleziona tutto

#include <stdio.h>
#include <math.h>	/* per atof */


#define MAXOP	100	/* dimensione massima di operatori e operandi */
#define NUMBER '0'

void push (double);	/* solo dichiarazione */
double pop (void);	/* solo dichiarazione */



/* calcolatrice in notazione polaccca inversa */

main()
	{
		int type;
		double op2;
		char s[MAXOP];

	while ((type = getop(s)) != EOF)
	{	
		switch (type)
		{
			case NUMBER:
				push(atof(s));
				break;
			case '+':
				push(pop() + pop());
				break;
			case '*':
				push(pop() * pop());
				break;
			case '-':
				op2 = pop();
				push (pop() - op2);
			case '/':
				op2 = pop();
				if (op2 != 0.0)
					push(pop() / op2);
				else
					printf("errore: divisione per zero\n");
					break;
			case '\n':
				printf("\t%.8g\n", pop());
				break;
			default:
				printf("errore: comando %s sconosciuto\n", s);
				break;
		}
	}
	return 0;
}

#define MAXVAL 100 /* massima profondità dello stack */

int sp = 0; 		/* puntatore allo stack */
double val[MAXVAL]; 	/* stack dei valori */

/* push: inserisce f in cima allo stack */
void push(double f)
{
	if (sp < MAXVAL)
		val[sp++] = f;
	else	
		printf("errore: stack pieno; %g non inseribile\n", f);
}

/* pop: preleva e ritorna il valore in cima allo stack */
double pop(void)
{
	if (sp > 0)
		return val[--sp];
	else
	{
		printf("errore: lo stack è vuoto\n");
		return 0.0;
	}
}

#include <ctype.h>

int getch(void);		/*dichiarazione*/
void ungetch(int);		/*dichiarazione*/

/* getop: legge il successivo operatore o operando numerico */
int getop(char s[])
{
	int i, c;

	while((s[0] = c = getch()) == ' ' || c == '\t')
		;

	s[1] = '\0';
	if (!isdigit(c) && c != '.')
		return c; 			/* non è un numero */
	i = 0;
	if (isdigit(c)) 			/* legge la parte intera */
		while (isdigit(s[++i] = c = getch()))
			;
	
	if (c == '.')				/* legge la parte frazionaria */
		while (isdigit(s[++i] = c = getch()))
			;

	s[i] = '\0';
	if (c != EOF)
		ungetch(c); 				/* se c != EOF */

	return NUMBER; 					/* se c == EOF */
}		

#define BUFSIZE	100
char buf[BUFSIZE];	/* buffer per ungetch */
int bufp = 0;		/* prossima posizione libera in buf[] */
int getch(void)	/* preleva un carattere (che potrebbe essere stato rifiutato in precedenza) */
{
	return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c)	/* rimette un carattere nell'input */
{
	if (bufp >= BUFSIZE)
		printf("ungetch: troppi caratteri\n");
	else
		buf[bufp++] = c;
}

[bite]

Mmh che peccato, per questa volta niente terno secco... dovrò lucidare la sfera di cristallo.

La dichiarazione di atof è in stdlib.h, non in math.h, sostituisci l'include e il programma va. Il problema è che il C accetta chiamate di funzioni non dichiarate e in mancanza di informazioni presume che l'argomento sia intero. Quindi la atof, che è presente nel link, viene chiamata con un argomento sbagliato.

Come mai funziona con MS? Probabilmente lì la atof sta in math.h.

Suggerisco anche di dichiarare la getop dove dichiari push e pop.

[geopardy]

Esatto! probabilemente atof é in math.h per ms quick c mentre in gcc è in stdlib.h. Per quanto riguarda la getop è dichiarata volontariamente dopo perchè non deve essere visibile dal main.
Cmq funziona (almeno sul gcc per windows, ora però lo devo verificare con gcc su ubuntu)
Ad ogni modo: Grazie!!!! (good)

[geopardy]

Ok, provato anche sul gcc di ubuntu, è tutto in ordine  (b2b)
Quindi, per chi a cui può interessare:

la funzione atof si trova:
  nella libreria math.h nel compilatore di ms quick c
  nella libreria stdlib.h nel compilatore di gcc

(per estendere la portabilità possiamo includere entrambe le librerie, no?)

GRAZIE 

[Spoon]

Arrivo tardi, visto che ormai avete risolto, comunque "nan" significa not a number...
Dovesse ricapitare almeno non sarà un errore così criptico :-p