Newsgroup: it.comp.lang.c
Titolo: ordine valutazione condizioni

ho un ciclo for in cui devo ciclare fino a quando sono verificate due 
condizioni.
Le due condizioni sarebbero da verificare in successione per cui se la 
prima è falsa la seconda non deve essere verificata, altrimenti si 
incarta il software.
Vorrei sapere se quando scrivo
for (i=0 ; condizioneA && condizioneB ; +ii) ;
sono sicuro che venga sempre verificata la condizioneA e poi la 
condizioneB se e solo se condizioneA è vera o se questo è solo fatto dal 
mio compilatore e non sta nello standard C.
Grazie


Puoi esserne sicuro solo se disabiliti l'ottimizzatore altrimenti dipende
dal codice che precede la _for_.
PS: Stai cercando di far diventare il '+' piů grosso ? ;-) (+ii).
Ciao.

 eseguito il controllo sulla seconda perchè il risultato è già determinato
Ciao,
hai ragione, dovrebbe essere così ma purtroppo, in più di un'occasione, il
disassemblato ci ha dato torto finchè non ho disabilitato l'ottimizzatore.

disassemblato ci ha dato torto finchč non ho disabilitato l'ottimizzatore.
Io non ci credo. Puoi darmi un frammento di codice e quale
compilatore hai utilizzato ?
Andrea

 if (foo != NULL && foo->bar > 123)
indipendentemente dal livello di ottimizzazione impostato?

 indipendentemente dal livello di ottimizzazione impostato?
La precedenza degli operatori e' "da standard" non "da ottimizzatore".
Gli operandi di un AND logico vengono valuitati da sinistra a destra:
prima viene calcolato il valore dell'espressione foo != NULL e (se
risulta vera) poi viene calcolato il valore dell'espressione
foo->bar > 123.
Il tutto, indipendentemente dall'ottimizzazione.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Il tutto, indipendentemente dall'ottimizzazione.
che bella notizia che mi dai :-)
non devo riscrivere un fracco di linee di codice :-)

 Andrea
Ciao,
il codice non lo scrissi apposta quindi dovrei andare per tentativi. Posso
però rammentare la situazione. Innanzi tutto il compilatore era Micosoft C
5.11 ed il sistema MS-DOS 3.1 o 5.0 (non ricordo), e non mi ha dato solo
quel problema. Il computer aveva a bordo una scheda di acquisizione di
segnali elettrici (timestamp) ed i dati venivano trasferiti nel buffer
dell'applicativo via DMA, quindi in modo asincrono. Nello stesso modo
venivano aggiornati gli indici del buffer. Durante l'elaborazione veniva
verificata la congruenza del segnale ricevuto ed in particolare qualche
linea di codice prima della famigerata while/for veniva effettuato un test
(if) simile a quello a sinista della and nel while. Ebbene, arrivati al
while quel test non veniva nuovamente effettuato. Purtroppo, data
l'asincronicità con cui si modificavano i dati nel buffer, questo problema,
di tanto in tanto, non permetteva la corretta analisi del segnale elettrico.
Problemi simili li ho riscontrati anche nella scrittura di programmi
residenti e questo è facilmente verificabile. Supponi di evere residente un
servizio interrupt a cui, da programma, passi l'indirizzo di una tua
variabile che il servizio setterà a 1 o 0 a seconda del verificarsi o meno
di un evento. Quando nel tuo programma testerai la tua variabile, il cui
valore viene ovviamente modificato in modo asincrono, nel disassemblato
noterai che questa non verrà mai testata perché non è mai stata "vista" a
sinistra di un uguale.
Sono passati parecchi anni, magari queste cose sono state riviste/corrette.
Parlando di problemi, il linker (ver.3.66) linkava senza batter ciglio
oggetti di modello large con oggetti di modello compact quindi venivano
fatte chiamate far a funzioni che terminavano con delle ret anzichè retf con
conseguenze disastrose.
Un saluto.

 Un saluto.
Il linguaggio C (e per molti versi anche il C++) non
ammettono che chi sta programmando commetta errori;
la filosofia e' che il programmatore sa cosa sta facendo.
Errori come quelli che descrivi sono a carico tuo, non
del compilatore. Non e' molto diverso da avere un .h che
dichiara un certo prototype e una implementazione della
funzione che usa parametri differenti... il compilatore
non e' tenuto a fare questi controlli; se scoppia tutto
e' solo colpa tua.
HTH
Andrea

 correttamente riletta ad ogni iterazione.
- Dario

sostituisci "compilatore" con "il codice prodotto dal compilatore"
Semmai con "codice prodotto dal compilatore".
Grazie per la quasi corretta precisazione.
Andrea
PS:
  Comunque mi scuso con il newsgroup per aver risposto
  a "maxime" senza prima aver fatto qualche ricerca.
  Fra le frasi lasciate all'eternita' di google citero'
  un paio di perle...
  "La differenza sta nel fatto che non tutti i
  compilatori accettano che sia il ritorno di una
  chiamata ad una funzione ad inizializzare una
  variabile che sta per essere dichiarata/allocata (fp)"
  "... e poi rispondo sopratutto a persone che hanno
  l'età anagrafica che corrisponde ai miei anni di
  esperienza nello sviluppo di sistemi operativi."
  Credevo fosse un principiante con le idee confuse
  che si stava avviando verso il pericoloso sentiero 
  dell'incolpare i compilatori per i suoi bug.
  Temo purtroppo che si tratti invece di un caso
  ormai irrecuperabile.

 ... linker ...
Allora, per congruenza, non avvisarmi nemmeno se i modelli di memoria non
sono solo il large ed il compact.