Discussion :

[hegros]

Je crois qu'il y a confusion.

une variable locale à une fonction si elle n'est pas déclaré static est détruite en sortie de la fonction.
Si elle est de type pointeur et qu'une allocation dynamique a été faite alors les données sont bien présentes sur le tas mais tu ne pourras plus y accéder sinon je suis curieux de voir comment...

[Melem]

Ah oui c'est vrai. Les données allouées sont belles et bien intactes mais le pointeur sur ces données, qui est ine variable locale automatique, est définitivement ou irrémédiablement perdu. Je m'excuse. Donc malloc() ca marche pas mais les variables locales static (ce sont bien des variables locales quand même hein! ) ca marche. Mais ca ne change rien à la manière d'utiliser longjmp() avec ou sans signal .

[Médinoc]

(hegros: Dit plutôt "perdue" que "détruite" dans le cas d'un longjmp().
Enfin, ça ne fait pas de grande différence ne C puisqu'il n'y a pas de destructeur. Mais s'il y en avait, ils ne seraient pas appelés lors d'un longjmp())

Melem: Content qu'on soit parvenus à se comprendre.

[turbo_chess]

Bonjour,

quand il s'agit d'écrire un intérpréteur , c'est obligé d'utiliser les goto, est ce qu'il y a une autre solution

Turbo_chess

[Médinoc]

Je ne vois pas pourquoi ce serait obligé...
Un interpréteur est généralement plus ou moins un automate d'états fini, qui n'a pas besoin de goto...

[Emmanuel Delahaye]

Oui parce qu'une variable locale static c'est quand même une variable locale!

Ceci n'a aucun sens, parce que ce n'est pas assez précis.
Un variable 'locale' statique est une variable persistante de portée locale. Voilà.

http://emmanuel-delahaye.developpez....page=Page4#XVI

[souviron34]

Dans le main() il n'y a ni if ni boucle mais chaque fois qu'une division par 0 a lieu, le signal SIGFPE est généré. C'est à fpe_handler() qu'on a donné la charge de traiter cette exception. Pour retourner quelque part dans main(), on utilise longjmp(). Voilà un des interêts de sauter quelque part dans une fonction fille, mère ou tante comme certains le disent. Et tout ca c'est pas fesable avec du goto.

En plus ce qui est bien avec cette technique c'est qu'en plus des signaux prédéfinis, on peut bien sur en créer des nouveaux à l'aide de simples #defines. Pour générer un signal (comme le throw du C++ ou de Java), on utilise la fonction int raise(int sig). Et tout ca bien sur, ca marche aussi bien sous Windows que sous OS/2 ou UNIX/Linux parce que c'est standard.

Et dernière chose, longjmp() permet de sortir rapidement d'une fnction profondément imbriquée donc il n'est pas seulement utile qu'avec signal.

Je persiste et je signe c'est inutile pour SIGFPE ou SIGDIV... Si la pensée est claire, le code aussi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int OK= 0 ;
 
while ( ! OK )
  {
     printf("Donnez-moi un nombre, je vais vous calculer l\'inverse.\n");
     scanf("%g", &x);
     if ( x == 0.0 )
       {
       }
     else
         OK = 1 ;
  }

Dans TOUS les codes de maths, il vaut mieux tester avant... Et si c'est pas des questions mais un calcul auto, alors mettre un flag d'erreur et éventuellement soit sortir soit avoir une valeur par défaut....

Quant aux fonctions profondément imbriquées , c'est aussi pire... un "return SUCCESS or ERROR" avec des tests dans la fonction du dessus marchent parfaitement et est LISIBLE et MAINTENABLE.

[Emmanuel Delahaye]

Si la pensée est claire, le code aussi :

+1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
     scanf("%g", &x);
     if ( x == 0.0 )

x étant un float, ca va pas faire....

Déjà, il faut tester la valeur retournée par scanf(), purger en cas d'erreur, puis pour 0, c'est éventuellement 0.0f, mais de toutes façons != et == ne fonctionnent pas avec les flottants. Il faut faire une différence, utiliser fabs() et voir si on est inférieur à DBL_EPSILON (<float.h>).

[Melem]

Je persiste et je signe c'est inutile pour SIGFPE ou SIGDIV

Tout a fait d'accord. Mais j'ai jamais dit que c'est la meilleure façon de calculer l'inverse d'un nombre, c'était juste pour donner un exemple d'utilisation de setjmp avec signal. Ce genre de code est très fréquent pour traiter le SIGINT par exemple. Avec goto on peut pas le faire. N'oubliez pas que c'est la le sujet du débat.

[souviron34]

+1

x étant un float, ca va pas faire....

Déjà, il faut tester la valeur retournée par scanf(), purger en cas d'erreur, puis pour 0, c'est éventuellement 0.0f, mais de toutes façons != et == ne fonctionnent pas avec les flottants. Il faut faire une différence, utiliser fabs() et voir si on est inférieur à DBL_EPSILON (<float.h>).

absolument, mais je voulais juste exposer le principe... (je fais systématiquement la diff. Mais d'ailleurs j'ai remarqué que c'était plus 1.e-06 que DBL_EPSILON... en général...)
(d'ailleurs dans le code original il lisait un double avec %f...)

Melem a écrit :

Ce genre de code est très fréquent pour traiter le SIGINT par exemple. Avec goto on peut pas le faire. N'oubliez pas que c'est la le sujet du débat.

J'ai fais beaucoup de traitement de SIGINT et je n'ai jamais utilisé de goto ou de jmp... Justement c'est là l'objet du débat..

[pi-2r]

A travers mes lectures d'apprentissage, j'ai appris à ne jamais programmer avec Goto, bien que j'ai lu des arguments traitant le pour du contre.
Personnellement, je trouve que cette fonction est trop bourrin...........

[David.Schris]

A travers mes lectures d'apprentissage, j'ai appris à ne jamais programmer avec Goto, bien que j'ai lu des arguments traitant le pour du contre.
Personnellement, je trouve que cette fonction est trop bourrin...........

"goto" n'est pas une fonction.

[pi-2r]

"goto" n'est pas une fonction.

c'est vrai, c'est une instruction ........

[LeFlou]

Je trouve que goto est utile dans certains cas très précis comme lorsque on veut aller vers une portion de code directement (désallocation de ressources par exemple) au lieu de l'écrire n fois... Je ne trouve pas la solution de faire une fonction où on passe tous les arguments à libérer plus élégante... bref si le goto est utilisé avec parcimonie et d'un coup d'oeil on comprend à quoi il sert je vois pas où est le problème.

[kromartien]

[Mon avis]

Je trouve que goto ça ne sert à rien, car dans un programme C, la programmation fonctionnelle est de rigueur.

Quel est l'intérêt d'un GOTO dans un code de moins de 10 lignes, et quel est l'intérêt d'une fonction qui ferait plus de 10 lignes et nécessiterait un appel au GOTO

Quel est l'intérêt d'un GOTO si la programmation ne se fait pas au numéro de ligne ?

Le C n'est tout simplement pas fait pour fonctionner comme ça, à moins que j'ai mal regardé.

Je conçois surtout un GOTO comme un moyen de faire de la récursion, et comme le C autorise la récursion de façon intrinsèque et sans GOTO, j'ai du mal à voir l'intérêt d'un GOTO.

Merci en tout cas de planter le mainteneur dans un source de 2000 lignes avec un gros GOTO au début du programme LOL trop sympa, la prochaine fois je le verrai venir.
[/Mon avis]

[David.Schris]

Je trouve que goto ça ne sert à rien, car dans un programme C, la programmation fonctionnelle est de rigueur.

Depuis quand le C est-il un langage fonctionnel ?

Quel est l'intérêt d'un GOTO dans un code de moins de 10 lignes, et quel est l'intérêt d'une fonction qui ferait plus de 10 lignes et nécessiterait un appel au GOTO

Désolé, je ne comprends pas.

Quel est l'intérêt d'un GOTO si la programmation ne se fait pas au numéro de ligne ?

Je ne vois pas le rapport (j'ai probablement mal compris aussi).

Le C n'est tout simplement pas fait pour fonctionner comme ça, à moins que j'ai mal regardé.

Le C a été fait avec le goto (d'ailleurs, c'est en minuscules) donc il a été fait pour pouvoir fonctionner comme ça.

Je conçois surtout un GOTO comme un moyen de faire de la récursion [...]

Peux-tu me donner un exemple de récursion faite avec un goto ?

[koala01]

[Mon avis]

Je trouve que goto ça ne sert à rien, car dans un programme C, la programmation fonctionnelle est de rigueur.

On peut traiter le C de langage séquentiel, ou de langage procédural, mais on ne peut pas le traiter de langage fonctionnel

Quel est l'intérêt d'un GOTO dans un code de moins de 10 lignes, et quel est l'intérêt d'une fonction qui ferait plus de 10 lignes et nécessiterait un appel au GOTO

Quel rapport entre le nombre de ligne et la présence ou non de goto

Si l'utilisation de goto est nécessaire (en se comprenant bien: s'il n'y a pas moyen de faire facilement sans), tu peux tres bien avoir une fonction de quelques lignes à peine, et avoir la présence d'un goto...

En plus, on a déjà du mal à faire passer le fait de limiter le nombre de ligne des fonctions à 50 lignes... alors à 10

Quel est l'intérêt d'un GOTO si la programmation ne se fait pas au numéro de ligne ?

On n'en est plus au temps du BASIC, qui nécessitait de savoir quel était le numéro de ligne...

Avec la présence des étiquettes (labels), et tout étant toujours lu "de haut en bas", cet argument ne tient absolument pas

Le C n'est tout simplement pas fait pour fonctionner comme ça, à moins que j'ai mal regardé.

Que du contraire... Et, d'ailleurs, du fait qu'il s'agit d'un langage procédural, il faut bien te rendre compte que tout bloc d'instructions créé en C est un bloc faisant appel à un goto de manière détournée

Je conçois surtout un GOTO comme un moyen de faire de la récursion, et comme le C autorise la récursion de façon intrinsèque et sans GOTO, j'ai du mal à voir l'intérêt d'un GOTO.

Heuu définis récursion

Merci en tout cas de planter le mainteneur dans un source de 2000 lignes avec un gros GOTO au début du programme LOL trop sympa, la prochaine fois je le verrai venir.
[/Mon avis]

Si tu avais lu l'ensemble du débat tu aurais vu que ce qui ressort principalement c'est:

1. Autant que faire se peut, éviter l'utilisation du goto
2. Si vraiment on n'a pas le choix:
   
   • Limiter au maximum son utilisation
   • Préférer un goto emmenant vers "la sortie" plutot que ramenant "vers l'entrée" de la fonction
   • veiller autant que faire se peut à ce que l'instruction ne soit pas trop éloignée de l'étiquette

De prime abord, il y a parfaitement moyen de s'organiser pour les éviter... et, de manière générale, c'est ce qu'il faut essayer de faire

Sans atteindre l'extrémisme d'un de mes profs qui menaçait de nous jeter par la fenetre si on l'utilisait, il faut reconnaitre qu'en de tres rares occasions, le goto reste malgré tout l'une des solutions potentielle à certains problèmes... Mais cela ne veut en aucun cas dire qu'il faut en utiliser à tous bouts de champs

[kromartien]

itération et non récursion. J
e me rappelle juste que le Goto c'est une instruction Basic, alors pour l'utiliser il faut mettre des étiquettes dans le code, du genre LIBL 4, ou si l'interpréteur numérote automatiquement les lignes, GOTO numligne;
J'ai juste du mal à concevoir que l'on puisse dans un programme C éparpillé dans tout un tas de fichiers utiliser des étiquettes et des goto.
Je pensais vraiment que la programmation procédurale, ou le fait de modulariser et de factoriser le code devait forcément restreindre, voire amener à faire disparaître complètement le GOTO au profit de simples structures conditions et rebouclages while, for.

[koala01]

Attention, il ne s'agit absolument pas "d'éparpiller" les gotos dans tout un tas de fonctions ou, pire, dans tout un tas de fichiers...

D'ailleurs, goto ne fonctionne qu'à l'intérieur d'une meme fonction... sinon, c'est un longjump qu'il faut utiliser

D'un autre coté, oui, bien sur, la programmation procédurale tend à restreindre de plus en plus l'utilisation du goto au profit de structures itératives/selectives diverses, bien sur, l'utilisation du goto est de nature à amener une certaine complexité dans une optique de factorisation et de modularisation, mais cela ne signifie aucunement que le goto ne doit absolument plus etre utilisé...

Si, la regle générale reste d'essayer d'éviter autant que faire se peut l'utilisation du goto, il n'en reste pas moins que toute regle a ses exceptions, et qu'on peut donc envisager de trouver de rares cas dans lesquels le goto reste l'alternative "la moins mauvaise" (car je n'irai pas jusqu'à la qualifier de "la meilleure" ) : à l'impossible, nul n'est tenu

[koala01]

En fait le longjump ou le jump, ce sont des instructions héritées du langage d'assemblage.

...Tout comme le goto, qui n'est qu'un jmp déguisé, ou l'appel/le retour de fonctions ...

Le C est l'un des langages de troisième génération ("proche du langage humain") qui soient le plus proche du langage machine/de l'assembleur...

Mais il faut bien te dire que, de toutes manières, quel que puisse etre le langage utilisé, tu finira toujours par retomber sur une construction basée sur les instructions qu'est capable de supporter le processeur

C'est ainsi que, bien qu'il soit décrié de manière de plus en plus insistante, tous les langages de programmation - en ce, y compris les plus récents - proposent une instruction qui se rapproche du goto, bien souvent de ce nom, d'ailleurs

Ce dont j'essaye de te faire prendre conscience, c'est que meme dans le cadre d'une simple structure de test "vrai/faux" du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
if(variable==value)
{
    /* do something */
}
else
{
    /* do something other */
}

cela fonctionnera sensiblement de la meme manière que le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
if(variable!= value)
    goto ELSE
/* do something if false */
goto ELSEEND
ELSE:
    /* do something if true */
ELSEEND:
/* continuing */

et que, du point de vue du langage machine, il y a de fortes chances pour que cela soit au final implémenté ainsi...

Et ce qui est vrai pour un test "vrai/faux" est vrai pour un "test à choix multiple" et pour les différents types de boucles que l'on peut envisager...

Finalement, la seule chose qui nous incite à éviter l'utilisation du goto, c'est juste la facilité apportée à la (re)lecture et à la (re)compréhension du code...

Evidemment, quand on pense au temps perdu à essayer de (re)comprendre un code donné ou à y chercher des erreurs si on ne comprend déjà pas ce qu'on (re)lit... on se dit que ce "simple" fait sera pour beaucoup dans la facilité que l'on aura à retrouver les erreurs

Mais voilà, pour paraphraser un écrivain qui faisait dire à son héros (soit aghata christie à H Poirot, soit conan doyle à sherlock holmes):

une fois écartées toutes les solutions impossibles, ne reste que la vérité, aussi improbable puisse-t-elle parraitre

on pourrait dire

une fois écartées toutes les solutions inapplicables, ne reste que la solution utilisable, aussi peu appréciable puisse-t-elle etre

Et donc, si aucune des structures existantes n'est sereinement envisageable, il ne nous reste plus qu'à nous tourner vers la solution "mere de toutes les autres": le goto