Newsgroup: it.comp.lang.c
Titolo: GOTO

ciao vorrei sapere se il goto una volta falto il salto incondizionato ...
'ritorna indietro'.
ES:
{
....
error: printf("Error");
.....
}
if(a!=0);
goto error;
a = 5;
la domanda č questa: dopo il   goto error;  ad 'a' viene assegnato 5 o si
eseguono le istruzioni che vi sono dopo  printf("Error");?
Scusate la domanda un po banale ma , č un dubbio che mi devo togliere...
grazie

 'ritorna indietro'.
No, dopo il goto esegui il codice dalla posizione del salto in poi... tutto
quello che c'era dopo il goto non viene eseguito. Nota che funziona solo
per salti locali.
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

il goto non si usa!
quello che vuoi fare con goto puoi sicuramente farlo anche con una
programmazione strutturata... usala! :p



Er goto... quanno ce vo'...ce vo'!

 :-)

:D

>programmazione strutturata... usala! :p
Sono circa 25 anni che programmo.
Ti assicuro che ci sono diversi casi nei quali l'uso del goto e'
assolutamente legittimo e consigliabile.
E' innegabile che puoi fare tutto o quasi senza, ma in alcuni
(rari, ma esistenti) casi l'uso del goto (per esempio: per uscire
da cicli annidati) ti puo' rendere un programma piu' vicino
all'algoritmo che avevi in testa e/o piu' leggibile e performante.
ciao.
g.

 g.
bhe.. io programmo da neanche un annetto e mi fido allora!
è che il nostro prof di info il goto non l'ha neanche spiegato dicendo che
tanto non lo dobbiamo usare

Ma per uscire dai cicli non si può usare break; ??????
break ti fa uscire da UN ciclo, ma non da tutti gli altri.
Se consideri il caso di cicli annidati:
for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
        for (k = 0; k < 10; k++) {
            if (condizione) break; -\
        }                           |
      <--- ti fa saltare qui -------/
    }
}
for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
        for (k = 0; k < 10; k++) {
            if (condizione) goto ....; -\
        }                               |
    }                                   |
}                                       |
                                        |
... <---- salti qui --------------------/
Questo è probabilmente l'unico caso in cui l'uso di un "goto" è
conveniente, ma io, onestamente, non lo userei neanche per questo, ci
sono alternative migliori, nel bene della programmazione strutturata.
-- 
Andrea Laforgia
Open Delphi Manual
http://groups.yahoo.com/group/delphi_open_manual/

tanto non lo dobbiamo usare
Intendiamoci: non ti servirà praticamente mai, ma omettere degli
argomenti per delle convinzioni personali non è corretto.  Tu dovresti
comunque sapere della sua esistenza e del modo in cui si usa, devi
essere consapevole che il suo uso è contrario alle norme comuni della
programmazione strutturata.  Usarlo o meno, poi, sarà tua discrezione.
Amputare degli argomenti dalla didattica perché non ci piacciono non
mi sembra sia molto corretto.


 sono alternative migliori, nel bene della programmazione strutturata.
Scusatemi :-D ma , anche sui libri e varie guide c' è scritto che comunque
ci sono valide alternative per non usare il goto.
Ma quali son queste alternative. Nel caso di cicli annidati .... Quale
istruzione potrei usare per uscirne completamente? Grz e riciao..

 istruzione potrei usare per uscirne completamente? Grz e riciao..
una flag?

 tanto non lo dobbiamo usare
Diciamo che il goto non si usa a scuola perchč cercano di farti comprendere
la programmazione strutturata.
A volte puň essere necessario il suo uso per rendere il tuo programma piů
performante, oppure perchč non trovi un modo migliore per cambiare il flusso
di esecuzione.
Per quanto mi riguarda lo uso spesso per uscire da una funzione in caso di
errore (per effettuare chiusure di file descriptor, rilasciare memoria, etc
etc) :
Ad esempio
void func(void)
{
while(1)
    for(;;)
        for(;;)
            {
                .................
                .................
                .................
                if(errore)
                    goto uscita;
            }
blocco istruzione n;
                if(errore)
                    goto uscita;
blocco istruzione n+1;
                if(errore)
                    goto uscita;
blocco istruzione n+2;
                if(errore)
                    goto uscita;
blocco istruzione n+3;
                if(errore)
                    goto uscita;
blocco istruzione n+4;
uscita:
    close(file_descr)
    close(socket)
    free(mem);        //    di tutte le variabili allocate.
    return;
}
in questo modo il programma risulta piů leggibile senza duplicazioni di
codice.
Ciao Gigi.

Quale istruzione potrei usare per uscirne completamente?
La programmazione strutturata non ammette che si possano "rompere"
certe "strutture" come i cicli, quindi una soluzione è quella di
adottare un flag di uscita:
for (i = 0; ((i<10) && (!uscita)); i++) {
    for (j = 0; ((i<10) && (!uscita)); j++) {
        for (k = 0; ((k<10) && (!uscita)); k++) {
            if (condizione_uscita) uscita = 1;
        }
    }
}
Ovviamente questo metodo non da la stessa efficienza del goto, perché
implica l'uscita progressiva da ogni ciclo "contenitore".


 --
Per finire diciamo che la goto è optional......in certi casi può rendere
meno leggibile e meno efficiente il codice ... in un altro caso esso
permette di avere 'più' controllo sulle uscite dai cicli o comunque ...
quando si verificano errori.
Giusto ? ;-D

 quando si verificano errori.
Io direi semplicemente che in alcuni casi rende il controllo piu' leggibile. 


Per finire diciamo che la goto è optional......
Se non fosse così, sarei già passato ad un altro linguaggio ;-)



In effetti ;-))

Ma per uscire dai cicli non si può usare break; ??????
Forse vi state confondendo... Non e' usando il 'goto' che si diventa
ciechi, e' a farsi le pippe (specie quelle mentali).
Il 'goto' non ha mai fatto male a nessuno, tranne a qualche prof. che
si rifiuta di credere che i linguaggi di programmazione servono solo a
scrivere software per computer.

 scrivere software per computer.
bhe... diciamo che correggerndo qualche programma di chi inizia ad
avvicinarsi alla programmazione sarebbe meglio se si imparasse a scrivere in
modo strutturato
comunque mi son spiegato male, non č cha ha fatto vedere la scritta "goto" e
ha detto questo č "tabů"
ha dato un rapido accenno e ha detto che non si dovrebbe mai usare (c'č
anche un teorema che dimostra che si puo' sempre scrivere tutto in
programmazione strutturata, giusto?)
:D

Il 'goto' non ha mai fatto male a nessuno[...]
Oh sě che lo ha fatto.  Never heard about "spaghetti-code" ?


ha dato un rapido accenno e ha detto che non si dovrebbe mai usare 
[...]
Ha fatto benissimo.


programmazione strutturata, giusto?)
Sicuramente evitare il goto e' possibile.
Che questa prassi sia di qualche utilita' invece e' piuttosto
difficile da dimostrare.
E' invece facilmente dimostrabile che qualsiasi artifizio introdotto
per evitare il ricorso al goto, non fa altro che appesantire il
codice, renderlo meno efficiente e piu' difficile da leggere.

Oh sě che lo ha fatto.  Never heard about "spaghetti-code" ?
In tal caso non e' l'istruzione ad essere in discussione, ma il suo
uso esasperato anche dove non serve.

Trovi forse che il mio post abbia qualche 'parvenza tecnica' ? =8-?
No, ed il punto è proprio questo.


codice, renderlo meno efficiente e piu' difficile da leggere.
*Dimostrabile* in che modo ? Stai cercando di dimostrare delle
opinioni personali.  Alquanto discutibile, perciò.  Io ritengo, per
esempio, che avere un controllo sul flag di uscita dai cicli annidati
lasci comprendere meglio cosa fa effettivamente il codice (esco, non
solo se arrivo a terminare l'elaborazione, ma se la condizione di
interruzione è attiva), piuttosto che delegare il compito a un goto
ficcato chissà dove.  In questo caso, pagare un pò di efficienza, a
vantaggio della leggibilità (che, appunto, *aumenta*, NON diminuisce)
è fattibile senza problemi.


è fattibile senza problemi.
Ok, ma questa e' soltanto una tua personalissima opinione.
Non discuto sul fatto che TU possa capire meglio un codice che
utilizza dei flag per uscire da cicli nidificati anziche' ricorrere al
goto.  Ma non credo che questo valga per la maggior parte di chi
programma.

programma.
La maggior parte dei programmatori dovrebbe imparare a fare le cose
per bene, ancor prima che pensare a problemi di efficienza.  Vediamo
se sei disposto a dire che utilizzi il "goto" nei tuoi programmi ad un
colloquio di lavoro ;-)



Ehiiiiiiii .... avevo detto per finire.. e state a litigare????
Cmq acc non č che mi voglio basare sui libri che dicono sempre: "Maiiiiii
usare il goto, che rende meno leggibile il codice". Usare il goto in un prg
di piccole dimensione... secondo me la facilita anche la lettura, ma ci
pensi ad usarlo in un programma di migliaia di linee di codice? Usciresti
pazzo secondo me... Soprattuto se il programmatore č molto 'attaccato' ad
utilizzare il goto...
.....................
ciao

Ehiiiiiiii .... avevo detto per finire.. e state a litigare????
Ti ricordo che questi si chiamano gruppi di *discussione*.  
Si discute e basta.  Il goto si può evitare benissimo anche per
programmi di piccole dimensioni.  Il guaio è che alcuni programmatori
rimangono ancorati a principi di programmazione validi 30 anni fa e
pensano di doverli applicare sempre e comunque, a prescindere
all'evoluzione dei paradigmi di programmazione e dell'hardware che li
circonda.  La realtà, poi, è che spostandoti su progetti di una certa
dimensione, se tiri fuori i "goto", la gente che lavora nel tuo team
ti fucila.


 Ehh già!!

Dal mio punto di viata un uso mirato di un goto in particolari casi puo'
semplificare la lettura del codice ed evitare la ripetizione dello stesso.
E' altresi' innegabile che un codice che abusi di goto per fare operazioni
semplici rischia di aumentarne la difficolta' di manutenzione.
Ci sono esempi di grossi progetti come il kernel di linux e rotor (la
versione shared source di .net) che usano il goto per migliorare la
leggibilita' del codice in punti particolarmente complessi in quanto, penso
di non offendere nessuno dicendolo, a volte l'uso di un goto e' piu' vicino
al pensiero umano di quanto non lo possa essere una sequenza di condizioni
in and, or, not ecc..
Capisco il punti di vista del professore, che nell'insegnare a gente che non
ha mai programmato, preferisce che questi si arrovellino il cervello nel
trovare delle soluzioni e non delle scappatoie: in quanto devono imparare a
pensare da programmatori e quindi avere confidenza nell'uso della
programmazione strutturata.
Un giorno quando diventeranno ottimi programmatori decideranno in base alla
loro esperienza ed alle esigenze di leggibilita' del loro codice se usare o
meno un goto ogni tanto perche' nei casi piu' semplici non penseranno
neanche lontanamente ad usarlo in quanto il buon codice gli "uscira'
naturalmente dalle dita".
Secondo me non c'e' una regola *assoluta* che dice quando usare il goto e
quando no. E' solo esperienza e buon senso.
Concludo con una bella frase che mi dicevano sempre da piccino:
"sempre e mai sono due parole che devi ricordare sempre e non usare mai"
ciao,
Nids
ps: analogamente ci sono guerre sante per quanto riguarda l'uso delle macro
e penso esattamente quello che ho detto precedentemente anche su questo
argomento

 individuare ed piu' semplice capirne lo scopo.
in un codice di 10 righe ti do' ragione, ma se ne hai 10 mila ??
il programma inizia a saltare su e giu' e non sai piu' neanche dove andarlo
a pescare!

colloquio di lavoro ;-)
E perche' non dovrei esserlo ?  Dopotutto ne sto discutendo
publicamente, non ti pare ?!? ;-)

 sono alternative migliori, nel bene della programmazione strutturata.
per esempio propagare il break ...
 for (i = 0; i < 10; i++) {
     for (j = 0; j < 10; j++) {
         for (k = 0; k < 10; k++) {
             if (condizione) break;
         }
if (condizione) break;
     }
if (condizione) break;
}
cosi' ottieni la stessa uscita di un goto, ma rimani in programmazione
strutturata, ed un buon complatore ottimizza tutte le if senza ritestare
sempre la stessa condizione, ameno di variabili dichiarate volatile.
ciao

 istruzione potrei usare per uscirne completamente? Grz e riciao..
la maggior mancanza che si sente nel c/c++ sono i break e i continue con
valore di salto ...
per esempio nel php (che ha un cuore c/c++ sotto) viene data la possibilita'
di usare dentro a cicli i break n; che chiudono n cicli sottotanti.
cmq in c/c++ si puo' ottenere la stessa cosa facendo come ho scritto
nell'altro messaggio, e si rimane cmq molto leggibili e si eliminano i goto
(che cmq si ottiene lo sttesso risultato con l'ottimizzazione)
cmq mi ripeto che sarebbe cmq bello avere:
for(;;)
for(;;)
for(;;) if (cond) break 3; o continue 3;
ciao

 di errori, quindi maggiore affidabilita'.
bhe... dei goto mal usati potrebbero far girovagare il programma a caso su e
giu' per il codice, dando effetti poco prevedibili.
magari un errore che si presenta nel ciclo A salta fuori 200 righe piu'
sotto...
con la prog strut. se il problema è nel ciclo A è probabile che il programma
si pianti nel ciclo A, in ogni caso sei sicuro del percorso che ha seguito
il codice per giungere fino al suo punto attuale.
con un goto non sai come il programma è giunto a quel punto, che operazioni
ha eseguito ecc.
:-)

 strutturata
bhe.. oddio... diciamo che come codice non è proprio il massimo... anzi!

 quando no. E' solo esperienza e buon senso.
Concordo pienamente !
Ciao,
g.

publicamente, non ti pare ?!? ;-)
Certo, solo che io mi firmo nome e cognome ;-)


quando no. E' solo esperienza e buon senso.
E` una questione di logica, non di buon senso (in programmazione ci
sono rari casi in cui usare il buon senso, è solo questione di
logica): i linguaggi di programmazione non crescono sugli alberi, la
gente li studia e li progetta.  I linguaggi strutturati sono stati
progettati in un certo modo perché si suppone che offrano un paradigma
di programmazione migliore di altri.  All'epoca in cui sono nati, non
era pensabile elidere il costrutto "goto", per via di un mare di
programmatori che erano abituati ad usarlo.  Oggigiorno, il paradigma
strutturato è stato metabolizzato (anzi, anche superato) e se ne può
fare benissimo a meno.  Io programmo da anni e non ho MAI (e dico MAI)
avuto l'esigenza di usare anche 1 solo goto.


 avuto l'esigenza di usare anche 1 solo goto.
Esperienze diverse o necessità diverse.
Ciao Gigi.

Esperienze diverse o necessità diverse.
Più che altro: modo di fare le cose diverso.  E` il modo di fare le
cose che distingue la buona dalla cattiva programmazione.
Ognuno è convinto delle sue idee, ma è bene evitare di aprire lotte
contro i mulini a vento, come chi crede di poter sbandierare l'uso del
"goto" come una necessità imprescindibile.


Mi dispiace dirtelo, ma il goto è un istruzione da eliminare, anche se
esiste.
Sicuramente migliora la leggibilità, quando ne è uno, ma poi per
manutenzione e aggiunta di codice nuovo in quei punti, diventa peggio del
codice scritto da microsoft :-)
Ti consiglio di usare le normali istruzioni e cicli che sono alla lunga
molto più chiare che dell'uso di goto.
--------------------------------
Inviato via 
http://usenet.libero.it

 "goto" come una necessità imprescindibile.
Anche questa e' retorica?
Scherzo, da un punto di vista accademico e' giusto sbandierare l'uso del
"goto" come una schifezza, da un punto di vista tecnico, anche molto
specifico può essere una necessità l'uso del "goto".
Saluti Gigi.

 I driver li scrivo in C il FW anche....
Mai usato 'goto' in un firmware scritto in C.
Steve.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Certo, solo che io mi firmo nome e cognome ;-)
E con cio' ?  Secondo te se cio' che scrivo fosse accompagnato dal mio
nome e cognome (anziche' da un nick) assumerebbe un significato
diverso ?

ha eseguito ecc.
In molti casi non c'e' differenza tra un sistema e l'altro, se ad es.
hai usato il goto per uscire da un ciclo in base ad una determinata
condizione, potrai semplicemente testare quella condizione per sapere
perche' ti trovi li'.
In ogni caso puoi sempre utilizzare dei flag, la stessa cosa la dovrai
fare nel caso in cui non usi il goto.

 fare nel caso in cui non usi il goto.
se hai una flag ed esci da un ciclo con quella controllandola all'uscita dal
ciclo sei sicuro che l'uscita è avvenuta per la flag, se usi un goto quando
ti trovi alla riga 1000 non sai se ti trovi li' perchè il programma ha fatto
un salto o perchè hai eseguito tutte le 1000 righe ed è arrivato li', è vero
che puoi testare la cosa con una flag, ma se un bug del tuo programma cambia
lo stato della flag nelle 1000 righe??? quando arrivi al controllo magari
sembra che ci sei arrivato per un lsato invece non è così!
cmq è una discussione senza fine...
io rimango della mia idea tu, della tua...

sembra che ci sei arrivato per un lsato invece non è così!
Ho come l'impressione che tu ti riferisca ad un altro linguaggio ?!?
Ma che razza di funzioni scrivi, 1000 e piu' righe ?!?

 Steve.
OK non ne hai mai avuto necessitą. Cio' non vuol dire che sia una istruzione
da eliminare. Cio' vuol dire solo che e' una istruzione che non usi e che a
me e ad alcuni altri rimane comoda ed utililizzo.
Forse "alcuni" sono "molti"!
Parlo ad esempio dei sorgenti dei driver di LINUX:
# cd /usr/src/linux-2.4/drivers
# grep -r goto * | wc -l
     6935
Puo' darsi anche che sia tutto codice programmato male (fatto con un cattivo
metodo di programmazione) come si diceva piu' su. Faccio comunque fatica a
crederlo.
Saluti Gigi.

 Forse "alcuni" sono "molti"!
Saranno anche tantissimi magari... tantissimi programmi che se li prende
in mano qualcun'altro fa prima a riscriverli.
Per tutto il resto sono d'accordo con Andrea, quindi evito di ripostare,
se vuoi altri esempi basta che fai un GOTO ai suoi post (bello quello dove
dice che anche andare contromano risulta utile, ma...).


Per me sono tutti problemi irrisori se usare il goto o no.Il goto deve 
esistere come normale estensione dei comandi supportati dal 
processore.Se notate tutti i set di comandi "assembler" sono supportati 
dal C perchè a volte è meglio sfruttare anche le caratteristiche + 
basilari del processore che fare giri strani per avere lo stesso 
risultato mettendo in crisi il compilatore o facendo codice molto meno 
performante.
Poi esiste un discorso meno semplice e è dovuto alle performance. Sfido 
chiunque a fare un programma che giri male su un pc moderno , minimo 
64mb di ram , velocità astronomiche , puoi permetterti di fare schifezze 
ovunque e nessuno se ne accorgerà mai ( nel limite del ragionevole).Io 
per lavoro programmo microcontrollori industrili e lì sono preso un po' 
oiù alle strette . 64 byte di ram sono standard di solito e velocità 
dell'ordine delle decine di mibs ( pensate che un pentium 166 fa circa 
12000mibs)[mibs = operazioni al secondo] quindi in questi casi tritengo 
lecito usare il goto perchè a volte una variabile in più non ci sta!
Poi su processori grossi è più un discorso di stile e regole. Io su 
programmi su pc non lo ho mai usato ma su programmi per micro si!
GRAZIE
<<SAX>>
E-mail:
linefin...@tiscalinet.it
Web Page:
http://xeus32.altervista.org

 64mb di ram , velocità astronomiche  [etc...]
Basta usare algoritmi inefficienti.