Discussion :

[Jack_serious]

Moi non plus j'aime pas les goto... il fut un temps où je les virais... Pourtant y'a pas que lui qui n'est pas structuré :
Mais dans un switch() case: break...

Je trouve tout de même une instruction switch beaucoup plus structurée qu'un goto. Contrairement au goto, je ne trouve pas qu'elle nuit à la lisibilité du code. Perso, je n'ai jamais utilisé la possibilité offerte par goto.

Meilleures salutations

Thierry

Idem, je n'ai plus utilise un seul goto depuis le temps ou je programmais en Basic sur ma calculatrice sur les bancs du lycee... (aaah les cours de physique).
Et je m'en porte tres bien.

[akoril]

OK pour le Goto, ce n’est pas beau…

Mais quand on parle de structure (voir réponse de Vic sur les break, continue, return…) je suis entièrement d’accord… et donc ce n’est pas la seule réponse pour ne pas utiliser le Goto.

Le seul langage qui respecte le flux de programmation… c’est le Lisp et ces dérivés… Pratiquez-le un peu (et même beaucoup) et vous connaîtrais les contraintes d’un respect des flux…

[Thierry Chappuis]

Le seul langage qui respecte le flux de programmation… c’est le Lisp et ces dérivés… Pratiquez-le un peu (et même beaucoup) et vous connaîtrais les contraintes d’un respect des flux…

Un code C bien structuré qui n'utilise pas de goto et qui n'abuse pas de la compilation conditionnelle respecte à mon sens relativement bien le flux de programmation. Qu'est-ce que Lisp a de plus à ce niveau? J'ai beaucoup de problème avec la synthaxe du LISP (et j'ai très peu d'expérience en programmation fonctionnelle), mais c'est vrai que je ne me suis pas acharné non plus. Je vais étudier cela de plus près.

Meilleures salutations

Thierry

[ogenki]

La regle : Pas de goto dans un programme

La valeur d'un programmeur est inversement proportionnel au nombre de goto que l'on trouve dans son code

Pour clarifier ton programme Utilise les sous programmes avec les commentaire qui vont bien

entierement d'accord avec cette regle goto est une aberation..

[Tellmarch]

bon dsl j'ai pas tout lu donc ça a peut etre deja été dit, mais il y a toujours l'argument d'autorité :

Dijkstra a dit que goto c'est mal :
http://www.acm.org/classics/oct95/

Et moi je lui fait confiance

[Thierry Chappuis]

Dijkstra a dit que goto c'est mal :
http://www.acm.org/classics/oct95/

Et moi je lui fait confiance

Ca c'est tout de même limité comme réflexion. Il faut se méfier des gourous et de leurs dogmes. En l'occurence, tu fais bien de lui faire confiance.

Thierry

[Tellmarch]

hm c'est pas si limité que ça, Dijkstra est un chercheur connu, et je m'appuis sur ses résultats... c'est une démarche courante

[Thierry Chappuis]

C'était juste la façon dont tu l'a dit! Je ne met pas en doute ses dires, d'autant plus que je suis d'accord.

Salutations

Thierry

[albokos]

Personellement j trouve que goto est indique pour resoudre uncertain nombre de problemes et notament ceux de saut d'instruction et j ne comprend pas non plus pourquoi elle sucite tant de crainte. une fois qu'on sait comment ca marche ce n'est plus du tou illisible je trouve.

[zerocoolyoussef]

je pense su'on doit profiter des avantages de la programmation structuré et ne pas abusé des goto.Car sutout pr les gens qui ont deja programmer en assembleur on peut simuler des tests des boucles jsute avec les gotos et le code et ne pas du tout claire et s'est en plus en plus difficile pr le maintenir ou le corriger.

[10_GOTO_10]

Bon, vu mon pseudo, je ne peux pas ne pas me mêler au débat. Vous l'aurez compris, j'ai fait du basic et de l'assembleur (donc, je suis définitivement perdu pour l'informatique, dirait mon prof).

Est-ce que les anti-gotos pourraient me dire comment faire le programme suivant sans goto ?

Soit le programme VHDL suivant (pas de panique, même si vous ne connaissez pas le VHDL, vous comprendrez quand même):

Code :

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

1
2
3
4
5
6
7
 
procedure TITI
  begin
  -- traitement
  wait on A
  -- suite du traitement
end procedure

Le VHDL est fait pour décrire des composants indépendants, donc chaque procédure tourne en parallèle.
Je voudrais faire un programme C (séquentiel, donc) qui simule ces composants. J'ai donc une fonction principale qui appelle chaque procédure alternativement. Sur le "wait on A", la procédure redonne la main à la boucle principale (donc un return), puis doit continuer le traitement à l'endroit où elle s'est interrompue quand le signal A (une variable globale, pour simplifier) est modifiée. Ca donne ceci en c:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int TITI(int suivi)
  {
  if (suivi == 1) goto suivi1;
  // Traitement
  // Equivalent du wait on A
  return;
suivi1:
  // Suite du traitement
  }

Je ne vois pas bien comment faire ce type de programme sans gotos, à moins de faire autant de threads que de procédures, sachant qu'on va vite être limité par le nombre maxi de threads autorisés par le système.

Mais je suis sûr que les anti-gotos vont me donner une solution élégante, structurée, et sans gotos...

[Emmanuel Delahaye]

Mais je suis sûr que les anti-gotos

Argh ! Je suis repéré !

vont me donner une solution élégante, structurée, et sans gotos...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int TITI(int suivi)
{
   if (suivi != 1)
   {
     // Traitement
     // Equivalent du wait on A
   }
   else
   {
     // Suite du traitement
   }
   return ...;
}

Trop simple. j'ai sans doute rien compris...

[10_GOTO_10]

Oui, c'est pas si simple: le wait peut être inclus dans des boucles et/ou dans des if (c'est à dire que le begin du if est dans Traitement et le end du if est dans SuiteTraitement). Il peut aussi bien sûr y avoir d'autres wait à d'autres endroits.

[Jean-Marc.Bourguet]

Oui, c'est pas si simple: le wait peut être inclus dans des boucles et/ou dans des if (c'est à dire que le begin du if est dans Traitement et le end du if est dans SuiteTraitement). Il peut aussi bien sûr y avoir d'autres wait à d'autres endroits.

Je ne vois pas en quoi goto aide. Si j'ai bonne memoire, on ne peut pas faire de goto vers l'interieur de structure de controle en C (ou bien est-ce uniquement en C++?).

De toute maniere pour implementer l'equivalent de wait, il te faut des coroutines puisqu'il peut y avoir toutes les variables de la pile d'appel a stocker. Si tu veux le gerer en C, il faut faire pas mal de chose a la main. Tellement que j'aurais tendance a definir un preprocesseur specialise pour ca, ou a tout le moins une lib complete bien pensee ce qui serait aussi du boulot. Pourquoi ne pas utiliser un vrai simulateur VHDL? Ou Verilog. Ou System C.

[10_GOTO_10]

(ou bien est-ce uniquement en C++?).

Heu, oui. je suis effectivement en C++. Ca ne change rien au débat.

De toute maniere pour implementer l'equivalent de wait, il te faut des coroutines puisqu'il peut y avoir toutes les variables de la pile d'appel a stocker.

Non, en VHDL toutes les variables sont statiques (on ne peut pas créer un bout de fil dans un composant et le détruire). J'espère qu'il n'y a pas de spécialiste VHDL dans le forum, je ne suis pas absolument sûr de ne pas dire une bêtise.

Pourquoi ne pas utiliser un vrai simulateur VHDL? Ou Verilog. Ou System C.

Alors celle là elle n'est pas mal: "N'UTILISEZ PAS DE GOTO !!! CHANGEZ DE COMPILATEUR AU BESOIN, MAIS SURTOUT N'UTILISEZ PAS DE GOTO !!!"

[Jean-Marc.Bourguet]

(ou bien est-ce uniquement en C++?).

Heu, oui. je suis effectivement en C++. Ca ne change rien au débat.

Je faisais allusion au fait qu'en C++ on ne peut pas faire de goto après une déclaration (et je me trompais car je pensais qu'on ne pouvais pas entrer dans un bloc quel qu'il soit). Ca montre que j'utilise peu les goto. Très peu.

De toute maniere pour implementer l'equivalent de wait, il te faut des coroutines puisqu'il peut y avoir toutes les variables de la pile d'appel a stocker.

Non, en VHDL toutes les variables sont statiques (on ne peut pas créer un bout de fil dans un composant et le détruire). J'espère qu'il n'y a pas de spécialiste VHDL dans le forum, je ne suis pas absolument sûr de ne pas dire une bêtise.

Tu peux avoir des variables dans les fonctions et les procédures. Mais je ne sais plus si tu peux avoir des wait dedans (cela fait un peu trop longtemps et j'ai surtout fait de la synthèse RTL où la syntaxe est plus contrainte qu'en simulation; en synthèse RTL, tu ne peux avoir qu'un wait par process et ce doit être le premier statement du process.).

Pourquoi ne pas utiliser un vrai simulateur VHDL? Ou Verilog. Ou System C.

Alors celle là elle n'est pas mal: "N'UTILISEZ PAS DE GOTO !!! CHANGEZ DE COMPILATEUR AU BESOIN, MAIS SURTOUT N'UTILISEZ PAS DE GOTO !!!"

C'est plus que changer de compilateur, c'est changer de language. Utiliser un language adapté plutôt qu'un avec lequel il faut bricoler pour manipuler les concepts, ça me semble être la base.

Les goto ne me gène pas. Je vais les utiliser s'ils correspondent à mon besoin. Je vais les utiliser pour bâtir la primitive adéquate. Mais je ne vais pas m'acharger à utiliser un langage qui ne propose pas la primitive sur laquelle toute ma conception est bâtie. Si je ne manipule que des coroutines, j'utiliserai un langage avec des coroutines, si je ne manipule que des machine d'états, j'utilise un générateur qui prend une description de machine d'états. Ou alors je bâtit ou j'utilise une bibliothèque de manipulation de coroutine ou de machine d'états (ce qui revient à utiliser un langage, la frontière entre les deux est fort poreuse). Si je n'ai qu'une routine, qu'une machine d'états, oui là je vais utiliser des goto de manière locale (encore que pour des coroutines, je crois qu'un switch est plus adapté).

[10_GOTO_10]

Les goto ne me gène pas. Je vais les utiliser s'ils correspondent à mon besoin.

C'est uniquement ce que je voulais dire à travers cet exemple (peut-être pas très bien choisi, j'aurais pu choisir un autre language, on est d'accord).
Je voulais seulement répondre aux inté... heu, intransigeant du C qui édictent des règles absolues, "les char *, c'est mal", "les goto, on peut toujours s'en passer", etc, etc. l'informatique en général et un language en particulier, c'est un outil. Il faut en utiliser les fonctionnalités qu'ils offrent, de la meilleure façon pour chaque cas, mais sans a priori sur la façon de faire. L'important est: 1) que ça marche. 2) que ce soit clair pour celui (sans doute soi-même) qui va le relire.

[loka]

je vais rajouter 3/ que ça nuit pas à la securité

il est vrai qu'à une epoque on ne pouvait pas s'en passer (mon vieux basic :p), mais maintenant en C/C++, tout peut se faire sans goto en ameliorant le code et sa securité.
Alors pourquoi vouloir continuer à l'utiliser ?

Enfin bon je l'utilisais quand j'etais très jeune sur les vieux langages de programmation, mais ensuite quand on m'a appris a programmer en C, on m'a toujours banni de les utiliser sous peine d'être flagelé

[akoril]

Salut,

J'ai plusieurs fois était confronté a ce genre de problème en reprenant du code existant, et en voulant supprimer les 'goto ERROR' (qui ne gêné que moi entre autre!) ...

Une solution est de decouper la fonction:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
bool TITI_Process(int suivi, int &rtVal) {
  if (suivi == 1) return true; // pour suite de traitement...
  // Traitement
  // Equivalent du wait on A 
  rtVal = valeurderetour;
  return false; // sans suite du traitement...
}
 
int TITI(int suivi) {
  int rtVal;
  if (TITI_Process(suivi)) {
     // Suite du traitement...
     // affectation éventuelle du rtVal...
  }
  return rtVal;
}

Le code de base n'est pas suffisamment clair... on doit pourvoir le faire en une seule fonction je comprend que l'on est dans une boucle ?
un essai:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int TITI(int suivi) 
{ 
  bool suite=false, end=false;
 
  while (!suite && !end) {
    if (suivi == 1) {
      suite = true;
      break;
    } 
    // Traitement... 
    // Equivalent du wait on A 
    break;   // ==> return; 
  } 
  if (suivi && suite) { 
    // Suite du traitement 
  }
}

Mais bon... a chacun ces méthodes de codage, l'essentiel c'est d'être assez clair pour des évolutions ou des corrections de Bugs et ça aussi bien par qq'un d'autre.

[Vigneau]

Le goto peut etre tres pratique mais doit etre utilisé avec soin. Il est notamment tres pratique pour la gestion d'erreur. Il permet notamment de creer un bloc pour les gestions d'erreurs et de centraliser la desallocation de ressources sur sortie d'erreur. En cas d'erreur il suffit de faire un goto sur un label a la suite duquel on procede à la desallocation et à la sortie de fonction. Cependant une regle pratique est d'éviter de faire un goto qui remonte le flot d'instruction, ce qui peut conduire a des cas délicats.