Newsgroup: it.comp.lang.c
Titolo: L'operatore && (domanda banalissima)

Salve a tutti,
probabilmente molti di voi mi insulteranno o inizieranno a ridere a
crepapelle non appena leggeranno la domanda che sto per porvi.
Beh! Ne sono consapevole !
La domanda riguarda &&.
Nella condizione   condizione_1&&condizione_2 vengono valutate entrambe le
condizioni, per poi farne il prodotto logico, oppure, visto che l'ordine di
valutazione è comunque da sinistra verso destra, se condizione_1 è false
allora condizione_2  *NON VIENE VALUTATA? *
Il problema mi si pone perchè se ho un array di 10 elementi, tanto per fare
un esempio,
int mio_array[10];
int size=10;
while((i<size)&&(mio_array[i]<80))
    i++;
e la condizione_2 non si verifica per nessuno degli elementi dell'array, con
l'utimo incremento accade che i==size ma mio_array[10]    **non è un
elemento valido**, il che mi procurerebbe un run-time error.
Se quindi le condizioni vengono COMUNQUE entrambe valutate questo
banalissimo ciclo va cambiato..... altrimenti è regolare.
Grazie in anticipo per la risposta,
Sebastiano

Se la prima è falsa la seconda non viene valutata.
dnt
--
____________________________________________________
________________________________________________
Visita il mio sito: 
http://members.xoom.it/DanxVB

while((i<size)&&(mio_array[i]<80))
&& e' uno di quegli operatori che (insieme alla virgola e a ?: )
introduce un ulteriore "sequence point" nella valutazione
dell'espressione e questo incide sull'ordine di valutazione.
Nel senso che viene sempre valutata prima la condizione a sinistra del
segno e solo dopo quella a destra (tieni presente che in generale
questo non e' vero, nel senso che il compilatore puo' procedere come
vuole nella valutazione). Ma questo non toglie che (non ricordo cosa
dice esattamente lo standard) non credo ci si possa pronunciare su
cosa eseguira' il compilatore : short-circuit o no.
Credo sia una questione dipendente dall'implementazione.
--
Andrea Laforgia (ICQ 87230455)
------------------------------ 
#exclude <windows.h>

Se la prima č falsa la seconda non viene valutata.
Non credo sia universalmente vero.
Penso che incida la natura del compilatore.


Ma allora è meglio "prevenire che curare", in quel caso specifico
dell'array?
Questo comunque significa che non è possibile generare codice portabile se
non tutti i compilatori accetano la stessa dicitura..... o mi sto
sbagliando, e la portabilità riguarda solo l'eseguibile?
Sebastiano

sbagliando, e la portabilità riguarda solo l'eseguibile?
La portabilita' riguarda *soprattutto* il codice sorgente.


 ha scritto nel messaggio
news:r776tsoafd4eikhvj...@4ax.com...


 *NON VIENE VALUTATA? *
 Ovviamente, dipendera` dal compilatore, ma penso che la soluzione
 piu` ragionevole sia quella del prodotto logico, che tradotto in
 assembler si trasforma in un'unica semplice istruzione macchina.
 In ogni caso, basta fare un programmino banale di esempio,
 compilarlo e disassemblarlo, oppure controllarlo in fase di
 running con un debugger tipo il SoftIce.

La domanda riguarda &&.
 [cut]
Anche a me pare che lo standard preveda short circuit.
Ho peró due osservazioni:
a) non confiderei nella conformitá totale allo standard da parte di
qualsiasi
compilatore, specie a questo livello di dettaglio;
b) quello che potrebbe capitare valutando mio_array[10]  non é a mio parere
un RT error: in generale dipende molto dalla piattaforma (e dalla fortuna
:)).
Certo non sarebbe quello che vorresti.
In sintesi, non scriverei codice cosí.
Francesco

Penso che incida la natura del compilatore.
Anch'io non sono certo al 100%, ma sono abbastanza sicuro che d.N.T abbia
ragione (cosi' mi aveva assicurato il mio prof di Programmazione).
Saluti,
    Mardy

 La domanda riguarda &&.
[root@fokhouse /root]# grep -A6 '^3.5' /usr/doc/FAQ/txt/C.FAQ
3.5:    But what about the && and || operators?
        I see code like "while((c = getchar()) != EOF && c != '\n')" ...
A:      There is a special exception for those operators (as well as the
        ?: and comma operators): left-to-right evaluation is guaranteed
        (as is an intermediate sequence point, see question 3.8).  Any
        book on C should make this clear.
[root@fokhouse /root]#
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

efficiente la valutazione di espressioni logiche come questa.
Se lo afferma lo standard, questo e' il comportamento standard.
In ogni caso, possono esserci compilatori che attivano un
comportamento alternativo in relazione all'attivazione di un flag di
compilazione particolare.


 allora condizione_2  *NON VIENE VALUTATA? *
<cite src="K&R2#A7.14">
	L'operatore && si raggruppa da sinistra a destra. Esso 
	ritorna 1 se entrambi gli operandi sono diversi da zero, 
	0 altrimenti. Diversamente da &, && garantisce una 
	valutazione da sinistra a destra; il primo operando 
	viene valutato, inclusi i suoi effetti collaterali; se 
	esso risulta uguale a zero, il valore dell'espressione e` 
	zero. Altrimenti, viene valutato l'operando di destra e, 
	se nullo, il valore dell'intera espressione e` 0, altrimenti	
	e` 1.
</cite>
	Alla prossima,
		Marco

Mi sembra che tutti sian concordi nell'affermare che lo standard prevede
valutazione short cirquit (da sx a dx, e se il primo e' falso il secondo
viene ignorato).
Pero' ci tengo a portarvi la mia esperienza: ho utilizzato un compilatore
che in prresenza di (a && b) valutava SEMPRE e COMUNQUE entrabe le
condizioni a e b, e POI faceva l'and logico.
Concordo con voiche e' una stupidaggine, e anche che non e' standard, pero',
almeno un compilatore che addotta questo comportamento esiste... e vi
assicuro che a me ha procurato un sacco di grattacapi!
spero il mio contributo possa servire.
ciao a tutti
bepin

assicuro che a me ha procurato un sacco di grattacapi!
Come gia' detto in un altro messaggio, e' possibile che esistano
compilatori che attivano la valutazione completa delle espressioni
booleane, in dipendenza dall'attivazione o meno di una direttiva di
compilazione. Credo sia difficile che un compilatore sia impostato per
default sulla valutazione completa ma, comunque, visto che lo standard
prescrive lo short-circuit, se il compilatore puo' essere impostato
per eseguire anche questo, e' un compilatore che, a tutti gli effetti,
ricade nello standard.


ricade nello standard.
Caro Andrea, avevo letto gli altri messaggi.
Ma il compilatore di cui parlo (e che tuttora sto usando) NON prevede lo
short cirquit.
Il compilatore e' della Toshiba, per dei processori che la Toshiba produce
(o produceva, non lo so).
Lo uso perche' parte del mio attuale lavoro consiste nel programmare dei
terminalini (fissi e portatili) che utilizzano proprio i processori della
Toshiba sopra citati.
Quello che uso, e' l'unico compilatore esistente per questi terminali, e ti
assicuro che non ha nessuna direttiva di compilazione che gli attivi lo
short-cirquit: lo ho (dolorsamente) sperimentato sulla mia pelle.
Se ti puo' interessare, ha anche almeno un'altro strano comportamento, che
riguarda la sscanf: lo stesso codice compilato in Win32 (con djgpp, VC++,
Borland o altro) funziona, sul termiale non funziona (ne abbiamo discusso
nel NG qualche mese fa, non so se ricordi...). Il tutto mi fa trarre la sola
conclusione possibile: il compilatore, purtroppo, non rispetta la standard.
Complimenti comunque per la qualita' dei tuoi interventi, sempre molto
sintetici e precisi.
Ciao,
bepin

sintetici e precisi.
Thanks ;)
