Sachant que la raison officieuse c pour eviter des enormes boucles chiantes ?

ça se justifie pas, c'est programmé avec les pieds

GOTO / LABEL , mon pere programme qu'avec ca.
 
Bon  OK, il programme en Basic sur MO6, mais bon

"ckomsaéfépachié"

et vive les spaghettis

 
ah bon ?
Pourtant moi je mets des EXIT partout dans mes progs Delphi !!

et moi j'oublie toujours d'effacer mes pointeurs en C

justification  ? -> optimisation du code !

goto c koa ça goto  

Tilys a écrit a écrit : goto c koa ça goto

 
c JMP en plus simple !

minusplus a écrit a écrit : justification  ? -> optimisation du code !

 
jolie excuse, copier/coller vers le rapport de projet !!  

Maldoror a écrit a écrit :     ah bon ? Pourtant moi je mets des EXIT partout dans mes progs Delphi !!

 
tu fais du delphi maintenant ?
même si c'est avec les pieds, c'est un bel effort

Depuis quelques temps ouais
J'ai pratiquement laissé tomber le langage en 16 bits sous lequel je développais jusque là depuis 4 ans

minusplus a écrit a écrit :     c JMP en plus simple !

 
merci j'aurai du préciser que ct du 2n° dsl de pas l'avoir fait  

Maldoror a écrit a écrit : Depuis quelques temps ouais J'ai pratiquement laissé tomber le langage en 16 bits sous lequel je développais jusque là depuis 4 ans

 
t'as aussi laissé tomber les cartes perforées

Ah ben voui, ça j'en ai eu au permis de conduire !!

Tilys a écrit a écrit :     merci j'aurai du préciser que ct du 2n° dsl de pas l'avoir fait

je m'en doutais !
 
 
(c t juste poor étaler ma science encyclopédique sur le sujet ! )

[edtdd]--Message édité par minusplus--[/edtdd]

minusplus a écrit a écrit :   je m'en doutais !     (c t juste poor étaler ma science encyclopédique sur le sujet ! )

 
ok ok je voyais arriver une réponse de se type
goto next topic  

Maldoror a écrit a écrit :     ah bon ? Pourtant moi je mets des EXIT partout dans mes progs Delphi !!

 
exit c'est pas un goto hein ; exit c'est plutôt un return...
y a pas de problème à utiliser exit (bien que j'essaie de pas trop l'employer).

un goto c'est sale, une vraie usine à gaz, moi j'ai déjà vu ça au milieu d'une boucle while, impossible à débugguer      

au moins ca justifieras le fait que PERSONNE sinon toi pourra le retravailler tellement ca va être un plan de nouille

OverFlow a écrit a écrit : au moins ca justifieras le fait que PERSONNE sinon toi pourra le retravailler tellement ca va être un plan de nouille

 
oui, mais même là, celui qui avait fait ça ne savait pas le débugguer  

Je ne vois pas ce qu'il y a de mal a utiliser 'goto', au contraire. Cela permet de sortir rapidement de plusieurs boucles sans passer par des immondes acrobaties genre variables 'est_ce_kil_faut_sortir_de_la_boucle' testees partout.
 
Les 'goto' permettent aussi d'eviter des niveaux d'indentation trop importants (sans sombrer dans la ridicule non-optimisation consistant a creer des fonctions qui ne sont appellees qu'a un seul endroit du programme) .
 
Une fois compile, un programme est compose en moyenne de 70% de goto ('jmp', 'bra', 'jump', etc) . Un 'if' se traduit par un goto. Un 'else' aussi. Un 'while' aussi. Un 'break' aussi. Un 'switch' aussi. Un 'return' avant la fin de la fonction aussi. La seule difference est que ces mot-clefs ne nomment pas les labels. C'est anonyme, implicite d'apres les acollades. Et souvent plus beaucoup plus flou qu'un simple 'goto ya_pu_de_memoire_on_se_casse' (qui ne bouffe pas de memoire et/ou registre inutilement) .
 
Ceux qui se revoltent contre les 'goto' ne savent simplement pas coder. Ils font du code 'propre' c'est a dire 10 fois plus long et lent que necessaire, sans avoir la moindre idee de ce qu'execute le CPU derriere.
 
A titre indicatif, le code source du noyau Linux comporte 14624 'goto' (grep -r goto /usr/src/linux | wc -l dans version 2.5.2-pre9) . Celui d'OpenBSD (3.0) en comporte 26138. Pourtant des milliers de gens travaillent dessus sans probleme. Mais ce sont des codeurs, pas des programmeurs. Pour un truc necessitant d'etre compact et rapide, se forcer a ne jamais utiliser 'goto' est de la debilite pure (ou c'est juste pour repeter betement ce qu'un prof a dit).

Personnellement je vois goto comme un sorte de try/catch en Java et C++. Pas vous?
 
axey > Trop de goto risque de rendre le code difficile à maintenir. Il faudrait donc trouver un équilibre, non?

[edtdd]--Message édité par Krueger--[/edtdd]

-> code spaghetti
 
euh "bande de pédé" , c'est sur blabla  

Je ne vois pas ce qu'il y a de mal a utiliser 'goto', au contraire. Cela permet de sortir rapidement de plusieurs boucles sans passer par des immondes acrobaties genre variables 'est_ce_kil_faut_sortir_de_la_boucle' testees partout.
 
Toutafé, mais il s'agit ici de l'émulation d'une exception, c'est faisable dans des langages qui ne disposent pas de ce mécanisme, mais c'est uniquement dans ce cas que je les accepterais.
 
Les 'goto' permettent aussi d'eviter des niveaux d'indentation trop importants (sans sombrer dans la ridicule non-optimisation consistant a creer des fonctions qui ne sont appellees qu'a un seul endroit du programme) .
 
Il n'y a pas que l'optimisation en vitesse qui est importante, mais quand tu te retrouve face à un code monstrueux, bonjour le temps de comprendre ce qui se passe. Une fonction qui n'est appelée qu'une fois ne me gène absolument pas (un compilateur intelligent va d'ailleurs l'expenser normalement), et cela permet à la fonction qui appelle cette fonction d'être relue plus facilement, car plus courte.  
 
Je préfère 100 fois un appel a une fonction : compute_maximal_machin que la fonctione expensée au beau milieu.
 
Accessoirement, si tu tiens à optimiser du code, je conseille la lecture d'un article paru dans LMF il y a deux mois sur l'optimisation de code C afin de tirer parti des pipelines des processeurs modernes. Interressant et sans goto
 
Une fois compile, un programme est compose en moyenne de 70% de goto ('jmp', 'bra', 'jump', etc) .
 
Si on a inventé des langages de haut niveau, c'est justement pour s'abstraire du coté spaghetti de ce genre de programme. Dans ce cas, pourquoi ne pas carrément debugger à l'oscillo. En effet, ces mnémoniques seront converti en courant électrique au sein du processeur.
 
Ceux qui se revoltent contre les 'goto' ne savent simplement pas coder. Ils font du code 'propre' c'est a dire 10 fois plus long et lent que necessaire, sans avoir la moindre idee de ce qu'execute le CPU derriere.
 
Oh, un véritable. Mais dans quel pourcentage des développements le gain est-il réellement interressant par rapport aux emmerdes derrière ? Quand j'écris du code, je sais que sa durée de vie (aka exploitation du programme) est de l'ordre de 10 à 15 ans, et que en cas de remontée de bug, quelqu'un (généralement un nouveau) va devoir mettre son nez dedans. Je préfère lui épargner de passer 3 jours dans un truc incompréhensible.
 
A titre indicatif, le code source du noyau Linux comporte 14624 'goto' (grep -r goto /usr/src/linux | wc -l dans version 2.5.2-pre9) . Celui d'OpenBSD (3.0) en comporte 26138. Pourtant des milliers de gens travaillent dessus sans probleme.
 
Le noyau d'un système d'exploitation est un cas particulier quand même. Deja, il y en a partie en assembleur (arch), ensuite il est en C dans les couches aux dessus, et je l'ai déjà dit, je suis pas spécialement contre une emulation des exceptions. Ensuite, une optimisation TRES poussée dans cette partie là peut vraiment valoir le coup, vu l'appel continuel à deschoses à la VM. De la même façon que si tu programmes pour une ROM, une optimisation en taille très poussée peut apporter des choses aussi.
 
 
Mais ce sont des codeurs, pas des programmeurs.
Elitisme p0w4h !
 
Pour un truc necessitant d'etre compact et rapide, se forcer a ne jamais utiliser 'goto' est de la debilite pure (ou c'est juste pour repeter betement ce qu'un prof a dit).
 
Es-ce tous les cas de programmations ? Loin de la. Aussi dire que le goto c'est bien,; c'est formidable, mangez-en vous serez un veritable(c), c'est du même acabit que ce que tu entends dénoncer.

moi j'ai utilise des goto dans ma vie
(quand je bossais sur amstrad CpC)
 
sinon j'ai utilise goto recemment
en C++ mais strictement limite
a une procedure sur un projet perso
pour parser rapidement une chaine.
mais c'est par paresse
et je crois que c'etait rendu
tellement simple par le goto
que je n'aurais pas de mal a revenir dessus.
 
A+
LEGREG

sinon la doc msdn ils ont une autre justification a vous de voir:

C'est pareil pour les exceptions il y a des gens
qui trouvent qu'utiliser des exceptions pour gerer
le flux normal d'un programme rend la chose difficile
a suivre et contraire a l'esprit des exceptions.
 
A+
LEGREG

ca peut etre propre un goto sur un prog de 340lignes, yen a 4/5. c meme pas pour des appels de fct mais pluto des retours  dans une execution lineaire. Dans ca cas je vois pas ou est le mal a les employer. sur que si c pour emplacer 3 boucles FOR imbriquées c porc, mais qd c pas ce genre de cas ya pas de prob a mon avis.
 

 
Tres bonne idée !!!      

Je veux pas f.... mon bordel, mais j'ai rien trouvé d'autre dans les progrs en batch !!!
En assembleur, on utilise pas goto mais des jump, ce qui revient au même...

[boulet]
tip de programmation:
Pour se deplacer dans un programme
le plus rapide c'est tout de meme le runto
mais il est deconseille
surtout dans les pools (plantage assure)
tout bon programmeur preferera donc
la methode walkto bien plus safe.
[/boulet]
 
A+
LEGREG

label goto selon moi n'a qu'une seule utilisation. Lorque tu es dans une double boucle et que tu souhaites sortir des deux boucles d'un coup
 
genre
 
while ...
{
   ///
   while ...
   {
    ...// Aller là (1)
   }
   ...
}
// Venir ici (1)
 
A+

tiens je viens de lire un truc dans la doc de Delphi : on ne peut pas faire un goto hors de la fonction dans laquelle on est :

 
N'est pas accepté par le compilateur. Il faut déclarer les labels :

et si on déclare le label sans l'utiliser ça provoque aussi une erreur.
 
En C ça se passe comment ? Y a pas toutes ces restrictions il me semble.

[edtdd]--Message édité par antp--[/edtdd]

 
En C, il faut faire ton goto
a l'interieur de ta fonction.
 
Il y a le mecanisme longjmp (nonlocal goto)
qui permet de faire des sauts
plus lointains mais qui fonctionne
differemment du goto
c'est a dire qu'il faut d'abord memoriser un point
d'execution avant de pouvoir faire une  
sorte de flashback a ce point.
 
L'utilisation du longjmp est deconseille pour
tout sauf pour gerer un mecanisme d'exceptions en C.
Et il est deconseille pour tout en C++
(puisque les exceptions existent et que longjmp
ne respecte aucune convention du C++).
 
A+
LEGREG

 
hop ca a deja ete dit
 
LEGREG
ps: mais je suis bien d'accord que c'est parfois
lourd de lire toute la discussion

 
Mouai, et encore c limite... Franchement les break et continue sont plus simples ! Tu veux le forcer à sortir des 2 boucles ? Tu met la condition de sortie de la boucle la plus large sur vraie et tu fait un break dans la boucle ou tu est ! Zooo dehors

Bruce a écrit a écrit :   Tu met la condition de sortie de la boucle la plus large sur vraie et tu fait un break dans la boucle ou tu est ! Zooo dehors

Ca c'est du bidouillage à la 6-4-2 pour éviter d'utiliser un goto c'est tout  

[edtdd]--Message édité par DarkLord22--[/edtdd]

legreg a écrit a écrit :     hop ca a deja ete dit   LEGREG ps: mais je suis bien d'accord que c'est parfois lourd de lire toute la discussion

 
Oups désolé