Newsgroup: it.comp.lang.c
Titolo: Ordine di valutazione

Ciao!
Lo standard garantisce un ordine certo di valutazione in una espressione
condizionale cosi` fatta:
if (condizione1 || condizione2 || ... || condizionen)
grazie 
kao.

if (condizione1 || condizione2 || ... || condizionen)
Si.
Lo standard garantisce che le espressioni vengano valutate nello stesso
ordine in cui sono scritte.
Inoltre se una delle condizione è verificata le altre non sono valutate.
Es.:
...
if (condizione || funzione(parametro))
...
In questo caso se la prima "condizione" è vera, la "funzione" non viene
chiamata.
Quindi occhio agli effetti collaterali... non desiderati.
Ciao, Angelo.

...
Sono convinto che scrivendo una espressione del tipo
if ((x=funzione1()) == 0 ||  (y=funzione2(x)) != NULL ||
		(funzione3(x, y)) == 0) exit;
la cosa funzione, ma non ho la certezza che lo faccia sempre, e poi:
il compilatore si dovrebbe fregare di cio`.
Tanto per capirci, il risultato del codice precedente e` uguale sempre
e in tutto a
if ((x=funzione1()) == 0) exit;
if ((y=funzione1(x)) != NULL) exit;
if ((funzione3(x, y)) == 0) exit;
No lo chiedo per forza a te, e grazie della risposta.
kao.

if ((funzione3(x, y)) == 0) exit;
Questa cosa e' vera solo se fai riferimento all'istruzione "exit".
Non vale, in linea generale, per tutte quelle che non interrompono il
flusso del programma.
---------------------------------
Andrea,
mica uno qualunque...
-----------------------------------------------------------------------------

No lo chiedo per forza a te, e grazie della risposta.
Prego, alla prossima.
Ciao, Angelo.

Si sempre.
Che vuol dire "sempre" ? 
Solo in questo caso (nel caso si usi la funzione "exit") il codice e'
equivalente a quello di sopra altrimenti no.
E' il primo quello piu' conveniente.


mica uno qualunque...
???
Senza rancore... Buone Feste!
Ciao, Angelo.

Perche' tu vedi del codice che gli altri non vedono?
Vorrei soltanto che la persona che ha chiesto aiuto non pensasse che
sostituire una serie di OR con una sfilza di IF fosse "sempre" la
stessa cosa.


Pace!
Buon Natale.
Angelo.

Buon Natale.
ahhahahah 
Buon Natale anche a te !


stessa cosa.
eccomi!
Mi sento un po` responsabile, perche` capisco di essere stato poco
chiaro, ma se avessi la chiarezza non avrei fatto la domanda...
Comunque ringrazio ugualmente tutti e due per avere risposto e
stimolato la riflessione su particolari aspetti della questione.
Per quello che ho capito, quando il particolare flusso logico del
programma lo permette, una serie di or logici appaiono preferibili ad
una sfilza di if :). E, se sono in tutto equivalenti dal punto di
vista del risultato, desumo che il vantaggio derivi da qualche 
sorta di ottimizzazione del codice.
No, non ho in mente di scrivere un compilatore, sapere cosa gli piace
di piu` ci puo` aiutare a scrivere codice migliore, tutto qui.
kao.

sorta di ottimizzazione del codice.
Il problema e' proprio questo.
i casi da discutere sono due :
1) if (condizione1) or (condizione2) or (condizione3) then calcola;
2) if (condizione1) then calcola;
    if (condizione2) then calcola;
    if (condizione3) then calcola;
E' sbagliato concettualmente ritenere che queste due forme siano
equivalenti.
Se le condizioni fossero vere tutte e tre, l'istruzione calcola
verrebbe eseguita una sola volta (caso 1)) mentre nel secondo caso 3
volte !
Sono invece equivalenti quando al posto di calcola c'e' un'istruzione
di uscita come exit, dato che, trovata la prima condizione vera,
quest'istruzione, bloccando il flusso, preclude la successiva analisi
delle altre condizioni, cosi' come, in modo analogo, succede nel caso
1).
E' per questo che mi ostinavo a dire che non e' SEMPRE vero che 1) e
2) sono equivalenti (praticamente non lo sono mai !) ma con un po' di
elasticita' si puo' dire che sono equivalenti se al posto di calcola
ci sono istruzioni che impediscono la successiva esecuzione degli
altri if (vedi exit)..


di piu` ci puo` aiutare a scrivere codice migliore, tutto qui.
Beh, io lo avrei comprato!
Ciao, alla prossima... e Buone Feste.
Angelo.

sorta di ottimizzazione del codice.
qualunque compilatore degno di questo nome non fa differenze fra una
fila di if ed una unica con OR, piu` che altro risparmi parecchie
cose:
- il codice e` piu` corto e piu` leggibile
- risparmi tempo nelle digitazioni
- il file .c diventa piu` piccolo
- consumi meno la tastiera
naturalmente se sei pagato per linee di codice scritte ti consiglio
una fila di if ;)
ciao
Buon Natale a tutti
[ranger, email: 
ran...@queen.it
]

fila di if ed una unica con OR
Davvero ?
Mi sa che non hai capito tanto bene come vengono trattate le
espressioni booleane.
Ogni compilatore degno di questo nome e' in grado di applicare il
ciclo completo o il ciclo corto nella loro valutazione.
Un "if" unico con tanti "OR" e' preferibile alla sfilza di "if" per
una questione di correttezza "logica" del programma e non perche' usi
meno la tastiera.
Se io scrivo 
if (condizione1) or (condizione2) or (condizione3) faccio si' che, se
condizione1 e' vera, non vengano controllate le altre.
(questo e' cio' che si intende per "ciclo corto").
L'esperienza della programmazione ti insegna che, a volte, se
condizione1 e' vera, analizzare condizione2 porterebbe ad un errore
fatale.
Esempio :
if (divisore = 0) or (dividendo/divisore = 2) allora scrivi ("bla bla
bla");
In questo caso analizzare _comunque_ la seconda condizione genererebbe
una divisione per zero con conseguente arresto del programma.
Ma e' solo uno degli infiniti casi presentabili.


ciclo completo o il ciclo corto nella loro valutazione.
il compilatore deve interrompere la valutazione appena puo` se vuole
essere ANSI


essere ANSI
I compilatori sono compatibili ANSI, quindi non "devono" interrompere
la valutazione, ma "devono poterlo" fare. 
------
Andrea
------