Newsgroup: it.comp.lang.delphi
Titolo: FOR..TO..DO.....STEP?

Ciao a tutti.
Sono incappato nel seguente problema, che può sembrare banale (forse
lo è davvero), ma non riesco a darne fuori se non gestendo la cosa
"manualmente" con un altro tipo di ciclo.
Dovrei fare un ciclo FOR nel quale il contatore non incrementa di 1
ogni volta, ma di un tot che decido io. Perfino il BASIC V2 del
Commodore 64 ha l'istruzione STEP per decidere di quanto incrementare
il valore del ciclo, idem nel C, possibile che in Object Pascal non ci
sia?
In BASIC (vecchio amato C64) la cosa sarebbe, per esempio:
FOR A = 1 TO 16 STEP 3
  CODICE DA ESEGUIRE
NEXT A
In C (se ben ricordo):
FOR (A=1; A<=16; A+=3)
  CODICE;
E in Delphi?
Grazie.
CIAO.
/|/|_Bozzy_|\|\

sia?
Con OP ti attacchi :) non si puo', devi usare un ciclo while.
Ciao,
Massimo.
-- 
"Ciao Rex, che cavolo di situazione eh? Due dentro, due fuori, puo' succedere di tutto!"

sia?
A := 1 ;
while ( A <= 50 ) do
begin
  ...
  A := A + STEP ;
end ;
--
Andrea Laforgia (ICQ 87230455)
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

 /|/|_Bozzy_|\|\
--
Andrea Raimondi
-------------------------------
Redattore corso di
Delphi di Software
Planet
-------------------------------
www.softwareplanet.net

> Grazie.
Si', secondo me e' la cosa piu' sbagliata che si possa fare(manca un
Goto e siamo a posto). 
Visto che stai scrivendo un corso di programmazione da te proprio non
me l'aspettavo :)
Ciao,
Massimo.

 wrote in message
jg3lbtod6egjuad45...@4ax.com...

Non ho mai detto che fosse un'esempio di stile... ho semplicemente indicato
il modo di fare quanto richiesto...
Ciò non significa che io lo adotterei o che lo condivida.
Però è quello che è stato richiesto ed io ho semplicemente risposto come si
fa il richiesto in Delphi.
Si chiedeva un for non un while o un repeat o quel che l'è.
Punto. Ed ho tenuto a specificare che si può considerare un'eresia( ed in
fin dei conti lo è ).
:=))))
Vedi, io credo che bisogna dare sempre la risposta cercata, anche se non ci
piace o esistono modi più corretti di fare la stessa cosa. Io non ho paura
di andare controcorrente, anche suggerendo soluzioni "sbagliate".
Ognuno deve fare il suo percorso, indipendentemente da ciò che noi pensiamo.
So che questa filosofia di vita può sembrare alquanto opinabile, ma alla
fine l'esperienza degli altri non serve mai( o molto raramente ).
Però come vedi io mi sono esposto con una soluzione certo orripilante, ma
che senza dubbio rispondeva "correttamente" alla richiesta. :=))))
Pensi abbia sbagliato?


io farei
var i,a: integer;
for i:=0 to Value div step do
 begin
  a:=i*step;
  // poi uso a come se fosse l'indice del ciclo
 end;

Goto e siamo a posto). 
Non solo è la cosa più sbagliata, ma credo addirittura che non venga
compilato, visto che è esplicitamente vietato modificare il valore
della variabile del loop in delphi (letto nell'help).
Cmq, grazie per le risposte, ho capito che devo attaccarmi e
ripiegare sul while..do, come ho fatto fin'ora.
Secondo voi, so che è una cavolata, ma che sia possibile consigliare a
Borland di inserire tale facilitazione dei cicli FOR per il Delphi 6?
CIAO.
/|/|_Bozzy_|\|\

Pensi abbia sbagliato?
Il bello della programmazione, IMHO, sta anche nel fatto che 100
persone possono raggiungere lo stesso risultato utilizzando 100
diverse soluzioni tutte valide. Pero', sempre e solo IMHO, ritengo che
alcuni schemi debbano essere seguiti perche' sono alla base della
programmazione. Uno di questi e' NON modificare mai un loop for (che
tra l'altro, non e'piu' possibile fare - ho appena provato e il
compilatore si arrabbia). Il bello (e forse il limite in certe
situazioni) del pascal e' che non permette di scrivere certe boiate
classiche del Visual Basic.
Altrimenti vale tutto:
A := 0;
Repeat
  Inc(A, Step);
  if A > 50 then 
  Break;
  ........
Until A > 50
(che voto mi daresti per questa roba? Eppure funziona)


 ha
scritto:

Questo č interessante, un buon ripiego. Grazie.
CIAO.
/|/|_Bozzy_|\|\

Pensi abbia sbagliato?
Purtroppo, si.
Dall'help del Delphi:
---
counter := initialValue to finalValue do statement
[...]
statement is a simple or structured statement that does not change the
value of counter.
---
CIAO.
/|/|_Bozzy_|\|\

 Pensi abbia sbagliato?
nello specifico, si'.
Saluti
Paolo Arosio

Questo č interessante, un buon ripiego. Grazie.
Onestamente, non capisco perche' ostinarsi a voler usare il ciclo for,
con dei salti mortali come quello precedente.
A questo punto, per ragioni di efficienza, e' molto meglio utilizzare
un while o un repeat...until.


end;
Una delle regole sacre della programmazione e' mai modificare l'indice
di un ciclo for all'interno del ciclo stesso.
--


 wrote in message
d0lmbt0ic8n8ln8ja...@4ax.com...

Sono d'accordo con Andrea, xchč ostinarsi? vabbč che programmare č un'arte e
quindi ognuno č "quasi libero" di esprimersi come vuole ma questi metodi mi
sembrano un pň naife. Si dice cosě? boh :))
Ciao
Simone

 E in Delphi?
Ciao Synthony, questo sono le classiche domande che
scatenano dei thread micidiali!
Io mi ricordo che quando programmavo in basic
non usavo mai lo Step, perche' mi costringeva
a farmi i conti *prima* di usarlo, cioč dovevo
prevedere che valori sarebbero ritornati,
e soprattuto, *quanti ne sarebbero ritornati*.
Es. supponi di avere una griglia di 10*10 coordinate
da tracciare...
io trovo molto piu' comodo
for y := 0 to 9 do begin
 for x := 0 to 9 do begin
  px := x * 10;
  py := y * 10;
 end;
end; // 88 caratteri digitati :)
...dove al posto del 10 posso usare
   un altro valore a mio piacimento
piuttosto che un ipotetico
for y := 0 to 100 step 10 do begin
 for x := 0 to 100 step 10 do begin
  px := x;
  py := y;
 end;
end; // 99 caratteri digitati :(
...dove sono a costretto ad giocherellare con la
calcolatrice per prevedere il comportamento di un
passo 10 in una dimensione 100
... si, si, ok! con 10 e 100 č facile, vabbč!
non so se mi sono capito... ;)
Ciao!
--
AmMaT
m   w
M   A
a   i
TwAiN

Ok mettiamo un pò d'ordine.
Mi limiterò a rispondere una volta, perché sono mentalmente stanco.
Normalmente risponderei a tutti, ma non in questo periodo.
Prima cosa: Anche io dopo aver mandato il messaggio ho pensato che forse ero
stato affrettato.
Erano passate le 22 ed avevo molti pensieri in testa.
Non posso difendere un codice indifendibile, questo sì che sarebbe poco
serio.
Il codice non testato... il codice non testato... beh, si, effettivamente
era non testato.
Poco serio postare del codice non testato senza dire che non è testato?
Forse, diciamo però che è molto meno serio criticare senza dare soluzioni
alternative.
Riguardo il mio corso, ognuno è libero di pensarla come crede e comunque, io
pubblico sempre, accanto alle risposte, dove si può trovare il mio corso...
<g>
Riguardo la mia posizione sulle soluzioni "sbagliate"( tra virgolette ), un
codice che anche non funziona può essere uno spunto a capire il perché.
A differenza forse di molti di voi, io ho avuto Internet per la prima volta
ben dopo che la mia... "storia d'amore" con lo sviluppo avesse inizio.
Tutto quello che so lo devo solo a molti sorgenti di esempio, a qualche
rivista ed a molte ore giornaliere passate sbattendo la testa contro il
monitor( alla fine qualche danno deve esserci stato... <g>) disperato dal
non riuscire a fare molte cose che avrei voluto.
Ancora adesso, io sbatto la testa contro tanti argomenti( interbase in
testa ), nel tentativo di far da solo senza chiedere.
L'iniziativa personale nella programmmazione è la vita. Senza di quella, si
diventa solo bravi a chiedere.
Non funziona? Capita, nessuno è perfetto.
Soprattutto con un computer lento, con poca RAM( 64 MB ), che deve caricare
Delphi Pro( badate bene che lavoro su un CELERON 450 ) testare un qualsiasi
pezzo di codice diventa impresa improba( metteteci vicino, Interbase Server,
2 firewall, 3 antivirus, Norton Crash Guard ) tutto in memoria. Tutto in
background.
Quindi testare su questo computer è un vero casino. Comunque torniamo a noi.
Tutti possono sbagliare. Ma da quello che non funziona, il principiante che
vuole imparare cerca di trarre una lezione esattamente come cerca di trarla
dal codice funzionante.
Quante volte io ho risposto qui o altrove, e non mi hanno mai ringraziato?
Sapete, ogni tanto fa piacere sentirsi ringraziare.
Volete dire che non ha mai funzionato niente di ciò che io ho postato? Non
credo.
E' facile criticare, meno facile è aiutare.
Per di più, io mi espongo alle critiche proprio per via del corso.
Ma quanti di voi lo hanno visto?
Io molto spesso non rispondo non perché non so, ma semplicemente perché è
inutile rispondere se hanno già risposto o se non ho alternative meritevoli
di un pensiero.
Le mie idee sono spesso non condivise, lo so bene.
So benissimo che io esprimo posizioni spesso impopolari, ma che vengono da
un'esperienza vissuta sul campo.
Io ho iniziato nel 1991, quando avevo 14 anni.
Per anni ed anni sono andato avanti da solo, contando su me stesso e basta.
Io non posto solo qui, ma anche su NG stranieri( quelli del TeamB, per
intenderci ).
Mi trovate spesso lì, anche più spesso che qui.
Spesso sono pure sulle news di Cantù anche se ora ci sto meno( Sui NG
Borland capita che rispondano anche i ragazzi del Delphi R&D ).
Scusate lo sfogo, forse anche eccessivo. Però cercate di leggerlo. E
capirlo.
Se ho sbagliato, come probabilmente ho sbagliato visto la valanga di si alla
domanda che concludeva il post,
ve ne chiedo scusa.


Pensi abbia sbagliato?
Certo.


linguaggi di 20 anni fa, se non prima).
Lo STEP non c'e' in Delphi, perche' non c'e' in Pascal e il Pascal non
l'ha inventato la Borland.  E' sempre meglio rispettare il subset
standard del linguaggio che si sta estendendo (Object Pascal =
estensione del Pascal standard).


 Ciao
Beh in effetti e' lo stesso, direi che sono soluzioni molto simili..
comunque non e' che la mia soluzione faccesse tanti salti mortali, faceva
solo un'operazione in piu' al ciclo...
Beh fa niente ! Saluti a tutti !                        {MSX}

 Borland di inserire tale facilitazione dei cicli FOR per il Delphi 6?
secondo me ti ridono in faccia ;)
no dai, seriamente, credo che Delphi offre e potrebbe offrire cose ben
piu' importanti che non uno step per un semplicissimo ciclo...
ps: pensavo di essere l'unico in grado di scatenare flames su argomenti
"inutili"... 8)
Ciao,
Alan Solo

Borland di inserire tale facilitazione dei cicli FOR per il Delphi 6?
MA PER FAVORE !!!


 ve ne chiedo scusa.
Caro Andrea, per me l'unica cosa che devi fare e'
prendere atto che quel sistema non funziona piu'.
Per il resto non hai nulla di cui scusarti.
Hai postato lo stesso codice che avrei postato io
fino a qualche tempo fa, ed io lo avrei postato
esattamente con la stessa tranquillita', poiche'
la possibilita' di modificare una variabile
che controlla un ciclo, per poco ortodossa che
fosse, funzionava! ...e quindi la davo per scontata.
Ed ho continuato a darla per scontata fino a che
con l'OP di delphi non sono inciampato in una
situazione simile a questa.
Ora, consideriamo tutti una cosa. Volenti
o nolenti tutti noi abbiamo qualcosa da imparare
l'uno dall'altro. Ed uno dei modi per farlo è, oltre
che chiedere, anche esprimere un parere, un'opinione.
Per favore, senza fare troppi discorsi, consideriamo
questro NG come se fosse uno strumento di debug per
le nostre imperfezioni. Perche' se e' cosi', allora
funziona e ci torna davvero utile per un'evoluzione
sia professionale sia meramente amatoriale. Se invece
serve per essere fukkati a stretto giro di post,
allora e'come quella famosa variabile che non puo'
essere modificata in un ciclo for loop: un bel giorno,
non funziona piu'.


 domanda che concludeva il post, ve ne chiedo scusa.
Le scuse sono accettate, ma se posso "osare" darti un consiglio, ti
consiglierei di accettare le critiche e gli errori (errare è umano) a fini
di crescita e non di disputa.
--
- Carlo -
c.b...@libero.it

non funziona piu'.
Prima di parlare di programmazione bisogna CONOSCERLA la
programmazione.  
Uno dei capi saldi della programmazione e' quello di non modificare
variabili in modo esplicito all'interno dei cicli for.


visto se hai fatto la prova di cui al punto 3).
Il test in Object Pascal e' MAGGIORE, non un test di uguaglianza.
Se esegui :
<CODE>
for I := 1 to 5 do WriteLn( I ) ;
WriteLn ; 
WriteLn( I ) ;
</CODE>
Avrai come output :
1
2
3
4
5
6 <--- valore maggiore dell'ultimo indice


dei cicli for.
... o come dicevo per l'appunto, essere fukkati
a stretto giro di post! :)
Mi spiace, ma non ti seguo!
Ho gia' postato in questo thread qualcosa
riguardo su come la penso e perche' lo penso.
Se lo leggi noterai che le mie posizioni a
riguardo piu' o meno si assestano sulle tue...
In che contesto gli esempi che hai postato
sono palesemente errati?
Vuoi dire che ci sono delle ridondanze nel
ciclo while? e che vuoi da me?... lo hai
scritto tu! eheheh! :P
Se invece pensi seriamente che questa tecnica
non abbia MAI funzionato, allora scaricati
questi 962k di amarcord e se proprio devi modificare
le variabili di controllo dei cicli fallo con una
certa discrezione dato che esse, se sovraccaricate
di "energia" tendono a "scavalcare" il ciclo stesso.
Come tu del resto, teoricamente, gia' saprai...
http://community.borland.com/article/images/20803/tp55.zip
Ciao Andrea!


Raga non sono arrivato fino alla fine... ma bisognerebbe fare critiche
costruttive... tenendo conto che tutti fanno cavolate....

Come tu del resto, teoricamente, gia' saprai...
???????????????????????
Ma che mi fai scaricare ??? il Turbo Pascal ???
Guarda che io lo uso dalla versione 1.0 !
Lo ripeto per l'ultima volta e questa volta cerca di capire, per
cortesia : la tecnica in questione non HA MAI FUNZIONATO, nel senso
che non HA MAI DATO i risultati attesi.
Il fatto che il compilatore (come il TP) non ti blocchi in
compilazione, non vuol dire che il tuo codice sia corretto.
Il Turbo Pascal, nonostante ti faccia modificare la variabile
all'interno del ciclo, conserva lo stesso comportamento di Delphi,
ovvero implementa un incremento in piu', che porta a dei risultati
completamente sballati.
NON SI PUO' RICOSTRUIRE IL FOR TIPICO DI BASIC CON STEP DI INCREMENTO
SE NON RICORRENDO A WHILE DO ... O REPEAT...UNTIL.


 A WHILE DO ... O REPEAT...UNTIL.
E su questo non ci piove!
Ciao Andrea e buon fine settimana!


 variabili in modo esplicito all'interno dei cicli for.
addirittura e' uno dei capisaldi della programmazione tutta ?!
Vabbe' che Pascal da molti non e' considerato un gran linguaggio, ma li
l'indice si poteva cambiare..

6 <--- valore maggiore dell'ultimo indice
Se leggi l'help del D5 scoprirai anche che il valore della variabile
di loop all'uscita dallo stesso _non è affidabile_ inquanto il
compilatore esegue delle ottimizzazioni sul codice del ciclo (le
stesse ottimizzazioni che impediscono di variare il valore della
variabile di loop all'interno dello stesso).
Perciò penso che il tuo esempio non sia di grande affidabilità, anche
se probabilmente in molti casi, ma non sempre, la condizione da te
riportata si verifica.
In ogni caso, grazie per tutti i suggerimenti più o meno validi.
CIAO.
/|/|_Bozzy_|\|\

non so se mi sono capito... ;)
Ti sei capito... o spiegato (?!?) bene. La mia domanda iniziale era
puramente a scopo conoscitivo, volevo sapere se c'era un modo per
farlo. Poi sulla comodità o meno dell'uso dello step, ci si potrebbe
scrivere un libro ;)
Cmq, grazie per i suggerimenti.
CIAO.
/|/|_Bozzy_|\|\

del C++ con l'equivalente forma Object Pascal.
Esattamente, e mi avete già risposto con almeno 3 metodi diversi (uno
con while..do, uno con repeat..until e uno con for..to..do usando una
variabile di comodo all'interno del ciclo), perciò io sono
soddisfatto. A che scopo continuare un discorso che ha già preso una
brutta piega?
Ripeto, GRAZIE A TUTTI! Ora ho capito cosa fare e cosa non fare,
grazie ancora!
CIAO.
P.S. I tempi sono cambiati, molte cose che una volta si potevano fare
e funzionavano, ora non funzionano più o semplicemente non sono più
accettate dal linguaggio. Prendiamone coscenza.
/|/|_Bozzy_|\|\

 6 <--- valore maggiore dell'ultimo indice
Dall'help di D5: "When counter returns the same value as finalValue,
statement is executed once more and the for statement terminates.
[...]After the for statement terminates, the value of counter is
undefined";
In particolare: il seguente ciclo:
var i: integer;
begin
  for i := 0 to 10 do begin
    label1.Caption := inttostr(i);
  end;
end;
viene compilato:
  xor ebx, ebx
  [*] ... ; istruzioni per l'inttostr
  inc ebx
  cmp ebx, $0b
  jnz [*]
quindi con un test di eguaglianza, non, come avevo erroneamente detto,
rispetto al valore finale del ciclo, ma a quel valore piu' 1.
Saluti
Paolo Arosio

>
Se ho sbagliato, come probabilmente ho sbagliato visto la valanga di si
alla domanda che concludeva il post, ve ne chiedo scusa.
<<
Non credo ce ne sia bisogno.
Se hai considerato personalmente offensivo il mio messagggio precedente
ti offro le mie.
Saluti
Paolo Arosio

SE NON RICORRENDO A WHILE DO ... O REPEAT...UNTIL.
Questo ormai mi è ben chiaro :)
CIAO.
/|/|_Bozzy_|\|\

possibilita'.
Da notare che è stata tolta dalle versioni a 32bit (Delphi >= 2) per
ottimizzare la compilazione dei loop. In Delphi 1 _dovrebbe_ ancora
funzionare (dico dovrebbe perchè non l'ho testato, ma ho letto che in
quella implementazione era ancora possibile variare la variabile di
loop all'interno dello stesso).
CIAO.
/|/|_Bozzy_|\|\


--
Andrea Raimondi
-------------------------------
Redattore corso di
Delphi di Software
Planet
-------------------------------
www.softwareplanet.net
P.S. Ho deciso di rispondere punto per punto, perché volevo chiarirmi con
te.

 Amici come prima? :=)
sa va sans dir (?)
Saluti
Paolo Arosio

 Saluti


 (visto che in Delphi 1 si può fare).
a parte che BASIC e PASCAL hanno una filosofia completamente diversa, e
il fatto che con il BASIC lo si possa fare e i Delphi no, non vuol dire
niente, puoi vedere i due lati positivi di entrambi,
BASIC e' piu' libero e PASCAL non ti fa fare cose che *non* si devono
fare... punti di vista... (il mio punto di vista si capisce ;)
se dovessi fare io un compilatore e un liguaggio di programmazione
vieteri anch'io la modifica dell'indice del ciclo...
se noti anche il codice assembly postato da Paolo Arosio puoi ben capire
se qualcuno modifica la variabile usata come contatore del ciclo si
rischia di fare un ciclo infinito se si incrementa di un'unita' di troppo
Ciao,
Alan Solo

vieteri anch'io la modifica dell'indice del ciclo...
Io no, così il tuo compilatore verrebbe scelto dai programmatori più
"canonici" e il mio dai più "smanettoni". Lasciamo scelta al popolo ;)
BTW, il BCB (per chi lo conosce) [scusate l'OT] permette la modifica
dell'indice di un ciclo for al suo interno?
CIAO.
/|/|_Bozzy_|\|\


sotto questo ed altri aspetti il compilatore C++ sotto BCB dovrebbe
essere pienamente std afaik.
for (int i=0; i < MAX_FOR; i += 127)
    label1->Caption = itoa(i);    // non testato
dall'help di BCB3:
int main(void)
{
 for(int i=0; i<10; i++)
 {
       cout << "Inside for loop, i = " << i << endl;
 }     // end of for-loop block
 cout << "Outside for loop, i = " << i << endl;  // error without -Vd
}      // end of block containing for loop
Saluti
Paolo Arosio

 dell'indice di un ciclo for al suo interno?
sinceramente non lo so (e non lo posso provare ora) cmq con C++ hai lo
"step", quindi non se ne avrebbe la necessita'
Ciao,
Alan Solo