Newsgroup: it.comp.lang.c
Titolo: true = !0

 (5 > 3) e' necessariamente 1 oppure e' solo !0 ?
Mi sembra che lo standard dica che falso e' 0, mentre vero e' >0.
Quindi penso che non si possa fare affidamento sul valore intero di un
"vero".
--
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it

(5 > 3) e' necessariamente 1 oppure e' solo !0 ?
Se non ricordo male, lo standard afferma che il valore e' sempre 1 per
true, come risultato di un'espressione booleana.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
-----------------------------------------------------------------------
"There is nothing better for understanding a kangaroo than seeing it jump."
[D.Grune, C.J.H. Jacobs]

> (5 > 3) e' necessariamente 1 oppure e' solo !0 ?
Per completare la carrellata io sapevo "ma non so se ricordo bene" che lo
standard dice che: falso è 0, e true qualsiasi altro valore.
Ho fatto qualche prova...
....allora con il:
Borland TurboC mi restituisce sempre true=1
Djgpp mi restituisce sempre true=1
Questo risultato però non può aiutarti molto, al massimo può confermare
l'ipotesi di Andrea Laforgia... se qualcuno trova almeno un compilatore che
restituisce true=(qualsiasi valore !0) allora sarebbe vera quella che ti ho
detto all'inizio.
--
________________________________
per rispondermi iliasba(at)
tin.it
bye Brain

 !0) allora sarebbe vera quella che ti ho detto all'inizio.
  Non fatevi fuorviare. Il fatto che un'espressione vera ritorni il
valore unitario non implica che altre espressioni ritornanti valori
diversi da zero non siano vere.
  Per esempio: e` possibile formalizzare una funzione in modo che
ritorni zero se il suo effetto collaterale e` stato portato a buon fine
ed un intero maggiore di zero altrimenti, indicando tale numero il
codice dell'errore incontrato. In questo modo, la funzione potrebbe
essere chiamata in uno statement di controllo del tipo:
<code>
	err_code=func();
	if(err_code) { /* error handling */ }
</code>
	Alla prossima,
		Marco

diversi da zero non siano vere.
Infatti non si sta discutendo di questo. Questo si sa.
Il problema e' capire se per lo standard, pur considerando vere tutte
le espressioni con valore diverso da 0, il valore di "vero" sia 1 per
default.
Cioe', se io scrivo 
(a > 1)
ottengo come risultato sempre 1 o puo' capitare (con qualche
compilatore specifico) che possa ottenere un valore diverso da 1 e da
0 ?


 0 ?
No.  Come tu dici prima, le espressioni logiche danno in _uscita_ o
zero (falso) o uno (vero); in _ingresso_, invece, un valore zero viene
interpretato come falso e tutti gli altri come vero.
Cfr. la FAQ list di comp.lang.c , Q/A 9.2 .
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 ottenere un valore diverso da 1 e da 0 ?
  Il seguente programma
<code>
	#include <stdio.h>
	int main()
	{
		printf("%d %d\n",!0,(5>4));
		return 0;
	}
</code>
stampa due begli uni, se compilati con il gcc (ANSI-pedante). :)
	Alla prossima,
		Marco

stampa due begli uni, se compilati con il gcc (ANSI-pedante). :)
Questo, pero', non significa che lo standard ammetta che bisogna
restituire 1. Anche se lo standard, abbiamo chiarito grazie a
Maurizio, lo specifica.


 bisogna restituire 1. 
  E` una condizione di necessarieta`, non di sufficienza. Se non altro,
pero`, avevamo la GNU-rilevanza. Ad ogni modo, il gcc, come si dice,
"claims to be standard compliant if invoked with the '--ansi'
parameter". ;)
	Alla prossima,
		Marco

parameter". ;)
Certo, ma per il principio e' che 1 ricade nei >0 ;)


 if ( ( a > b ) == TRUE )  ...
  Beh... non e` che rilevi molto. L'unica spiegazione che traspare da
questo brano di codice e` la necessita` di definire una macro TRUE che a
mio parere e` abbastanza inutile (per non parlare delle FAQ, che la
definiscono idi^H^H^H ehm, ingenua :) ).
<faq id="9.2" ref="
http://www.eskimo.com/~scs/C-faq/q9.2.html
">
	Therefore, the test 
	        if((a == b) == TRUE)
	would work as expected (as long as TRUE is 1), but it 
	is obviously silly. In general, explicit tests against TRUE 
	and FALSE are inappropriate, because some library 
	functions (notably isupper, isalpha, etc.) return, on success, 
	a nonzero value which is not necessarily 1. (Besides, if 
	you believe that ``if((a == b) == TRUE)'' is an improvement 
	over ``if(a == b)'', why stop there? Why not use 
	``if(((a == b) == TRUE) == TRUE)''?) A good rule of thumb is 
	to use TRUE and FALSE (or the like) only for assignment to 
	a Boolean variable or function parameter, or as the return 
	value from a Boolean function, but never in a comparison. 
</faq>
  D'altra parte, non potendo fare a meno di definire macro piu` o meno
inutili, anche
	#define TRUE !FALSE
puo` essere utile nell'assegnamento (sempre idi^H^H^ ingenuo, comunque,
nelle comparazioni).
  Ancora non ho capito, dunque, perche` ti sia tanto necessario sapere
che lo standard restituisce 1 per le espressioni booleane vere.
	Alla prossima,
		Marco
PS Quanto mi piace parlare del sesso degli angeli. :)

PS Quanto mi piace parlare del sesso degli angeli. :)
E' evidente che non hai capito il senso del post originale, pienamente
giustificato :)


 Io gli angeli li immagino con sembianze femminili. (-:
  Fai attenzione. :)
	Alla prossima,
		Marco

 pienamente giustificato :)
  Veramente era cio` che ti avevo chiesto tre o quattro post fa, ma tu
non hai voluto dirmelo. :)))
	Alla prossima,
		Marco