marrant... Mais comme ça, c´est encore mieux :

bool Fonction(){
if(Init(&1) || Init(&2))
return true;
else{
Clean();
return false;
}

On peut aussi faire :
bool fonction()
{
bool resultat;
resultat = Init(&1) || Init(&2);
If ( ! Resultat)
{
clean();
}
return resultat;
}
je sais je passe encore par une variable intermèdiaire mais je n´utilise qu´un seul result et il n´y a plus de else.

Pardon je me suis fais mal comprendre.
OK.

Bon pour repondre aux "re-ecriveur" du code :
on peut ecrire la meme chose de plusieurs maniere differentes. Au passage 1 call est plus lourd qu´un goto au nombre de cycle CPU. Vous declarez une fonction supplementaire... Supposez maintenant que le code retour de la fonction indique quelle a ete l´erreur levé et que vous ayez 15 initialisation a faire et que ces initialisation peuvent etre dependante les une des autres . ..

Pour en revenir au goto, c´est un element du language non ? Pourquoi s´en priver ?
Si vous acceptez de l´utiliser alors ( a mon avis ) il faut determniner dans quels cas.
Si on doit s´en priver alors pourquoi pas se priver du for ? De certains type ?
Cette instruction fait partie integrante du language. Autre point de reflexion : Qu´est ce qu´un try . .. catch si ce n´est qu´un goto deguisé ?

Alors lui on peut l´utiliser et po l´autres.

J´affirme que dans certains cas, le goto est justifié et elegant.
J´affirme aussi que mettre plus de 2 goto dans une fonction devient tres vite illisible voir voir incomprehensible ( condition d´emploi a bien definir).

Bien des livres annonce "PAS de GOTO vous cassez la programmation structurée" mais si le goto s´applique dans la meme fonction je vois pas ce qu´il y a de cassé.

Je repete : J´etais un partisant du "NON au GOTO" pis le temps passant j´ai vu des codes utilisant le goto pour branchement sur gestionnaire d´erreur et cela me parait justifié et elegant.

et moi comme ca

bool Fonction()
{
if( ( ! Initialise1(&1))&&(! Initialise2( &2 ) )) )
{
Libere(Module1);
Libere(Module2);
return false;
}
return true;
}

1 comme ca il n y a que 1 test ( le if)
2 il n y a que 1 seul brenchment de fonction vu que l on appele directe la fonction Libere et plus le goto

data
http://www.ploksoftware.org

LCData

Une comparaison ne prend qu´1 cycle CPU(0.5 si on optimise pour les instruction SSE2 du P4).
Par contre c´est que l´on peut supprimer l´appel à Clean.
Enfin tu as toujours deux returns , même si ce n´est pas faux.

Passage

Try..Catch est bien plus qu´un goto , puisqu´il fait une sauvegarde des registre processeur au moment du try puis une restauration au moment du catch,le goto lui ne fait rien de tout ça.

Pour le nombre de CPU c´est logique puisqu´il s´agit d´un Jump , il n´y a donc pas à toucher au stack register du processeur alors qu´un call incrémente stack register et le rempli la pile en conséquence(je sais plus dans quel ordre).

Personnellement je n´ai jamais utilisé de goto(en dehors de QBasic , et encore on peut le remplacer par Gosub avec un return à la fin de la sous routine).

Bouarf ! ...

INIT:
. .
. .
. .
RET 2

MAIN :
push word ptr mod1
call INIT
pop ax
cmp ax,0
jz suite
jmp erreur
suite:
push word ptr mod2
call INIT
pop ax
cmp ax,0
jz fin
erreur:
call clean
fin:
ret

C´est bô comme ça ? vous le voulez pas en lambda-calcul, non plus ? ?....

Vous me faites marrer quand même, vous programmez pas un réseau de neurones, la vitesse a moins d´importance.

Quant au goto, pourquoi pas de goto ?
Facile :

. ..
qqpart2
. ..
goto qqpart1
. ..
qqpart1:
. ..
goto qqpart2
. ..
qqpart4:
. ..
goto qqpart3
. ..
qqpart3:
. ..
goto qqpart4
. ..

Maintenant si vous arrivez à gérer les boules infinies de ce truc, vous êtes des champions du casse tête chinois.

Mon but n´était pas d´optimiser la vitesse d´exécution(car de toute façon ce n´est pas forcement le nombre d´instruction qui déterminent le temp d´exécution) mais juste de montrer que l´on peut toujours autrement sans utiliser les goto.
Avec les exemples de LCData et moi-même je pense que l´objectif est largement rempli.

Ok je reviens a la charge.....
C´est dur de se faire comprendre desfois, la pluspart du temps je le prends pour moi mais la je dois quand meme reporter un peu sur vous . ..
et ja je sens ( pour la premiere fois la moutarde me monter au nez ) .

D´abord, il semblerait que le source original ai perdu au cours des re ecriture sa fonctionnalité . ... ( Condition . ...) On oublie mais faudrat remettre de l´ordre dans la poullailler . ..

Alors on va faire derouler le tapis rouge pour vous....

Je reprends l´exemple mais cette fois ci on va faire 10 init.
Ca commence a faire un beau <if> non ?
J´suis pas à ca pret.

Bon apres faut lire tout les mots que j´ecris...
Je suis interresé en retour de cette fonction de connaitre quelle initialisation a raté.

"Supposez maintenant que le code retour de la fonction indique quelle a ete l´erreur levé et que vous ayez 15 initialisation a faire et que ces initialisation peuvent etre dependante les une des autres "

J AI BIEN ECRIS CA NON ? Dans le message precedent.

Sarafan =>
Vi le try catch fait une sauvegarde d´accords.
j´ai bien ecris "goto deguisé" ? ?? Dans le "déguisé" j´entends bien inclure cette sauvegarde.

Sarafan bis =>
"On peut ecrire la meme chose de plusieurs maniere differentes" Merci de le repeter ( ca use quand meme a la force). Ce que je souhaite demonter c´est qu´il peut etre elegant d´utiliser le goto.

ARG !

Uncursed :
OK c´est bien l´asm. OK. ( Faudrait il savoir ou se trouvre les fonction d´initialisation . .. Chez moi ou dans une lib, dans une DLL . .. Je ne les ai pas ecrites que je sache )
"J´affirme aussi que mettre plus de 2 goto dans une fonction devient tres vite illisible voir voir incomprehensible ( condition d´emploi a bien definir)."
J AI BIEN ECRIS CA NON ? Dans le message precedent. Le casse tete chinois s´arrete tres vite dans ce cas non ? De plus j´ai po ecris "Allez y a fond dans le goto . ..."

L´objectif n´est toujours pas rempli.
Je suis toujours bien embeté car personne de donne d´argument pour NE pas utiliser le goto.

Vous interdisez sans explications. Et vous annoncer que d´une autre methode vous le faites, mais bon sang ou est l´argument ?

Pardon si je suis trop "virulent" mais sur ce coup, la pillule est un peu grosse a avaler.

Si il est vrai que l´utilisation du goto est plus élégante , il n´en reste pas moins que l´utilisation de sous-procédure est bien meilleure et plus maintenable.
Faire des déplacement de code dans une procedure qui a des labels entrainera inévitablement des plantages si le programmeur n´est pas vigilant.
Le C est un langage procedural , le goto ( ce n´est que mon avis) fais perdre une partie de cet aspect au langage.

De plus tu remarqueras dans mes exemples que mes if
ne font pas la comparaison entre plus de deux éléments , dans le pire des cas je ferai une variable temporaire qui récupérera les résultats de toutes mes initialisation , en terme de lisibilité il est possible d´écrire une ligne sur plusieurs lignes , par exemple :

Resultat = init1 && init2 && init3 &&
init4 && inti5 && init6 &&
init7;

Ce qui pour moi est aussi lisible et élégant que ce que tu présentes

Enfin de toute façon l´utilisation du Goto est toujours source de polémique,on peut donc en parler pendant longtemp.

Arf ! Merci de cette reponse. Visiblement y a des arguments . ...
Oui on peut polemiquer a fond sur le goto j´chuis d´accord.

Ok, ta solution de stockage est tout aussi acceptable que celle du goto.

Ok a moitié pour le deplacement de code puisque, cette structure est rigide. J´entends par la que le label de saut est unique pour la fonction et ne peut se trouver qu´en fin de fonction ( Tiens ! c´est mes conditions d´utilisation d´un goto ) . Donc, je m´interroge sur le comment arriver sur un plantage... Mais c´et un argument, j´vais y reflechir.

Mais ( ben oui il a un mais ) tu est d´accords avec moi que dans ce cas la, la solution parait plus elegante ( le goto j´entends). Ce qui m´interresse ici c´est la maintenabilité du code. Attention pas la maintenance par une seule personne ( c´est bidon ca ) mais faire passer le source de mains en mains. Or si l´elegance c´est le goto, il me semble alors que lors d´une premiere lecture il est plus aisé de comprendre la struture avec le goto. Non ?

Ce que je crains dans toutes les autres solutions:
*Appel plusieur fois pour le meme cas d´erreur avec rajout du cleaner.
*Reconstruction du resultat ( comme tu le fais )

De mon avis ou non, je te remercie de cette reponse constructive. ( Ca calme merci )

Le goto correspond à un jmp en assembleur.
Une condition, correspond à un saut conditionel ( j*)

Bref, au final : pas de réelle différence une fois compilé.

Admettons ce code :

label_debut:
[...]
if(var==val)goto label_fin;
goto label_debut;
label_fin:

la même chose sans les goto :
do{
[...]
}while(var!=val);

Sincèrement, quel code est plus lisible ? ; )

Enfin, plus clairement, ce qu´on veut dire, c´est que utiliser les goto plutôt que les structures existantes au niveau d´un langage plus évolué, c´est un peu régresser au niveau de l´assembleur ( qui est un langage ultra chiant)

le goto est une relique des anciens languages comme le basic 2.0 mais avec l´ evolution du C et la maniere que dont on programme Actuellemnt on a en plus besoin.

tien on pourait relancer la polmeique avec l ´instruction "continue"

Data
http://www.ploksoftware.org

Ok, voila une disscussion plus interressante.

Uncursed :
Je suis d´accord avec toi sur ton exemple, l´utilisation du goto n´est pas justifié et de plus ( a mon avis degrade la comprehension )

Le goto c´est un saut inconditionnel ( jmp).
Le if c´est un saut coditionnel ( j*).
En quoi l´utilisation d´un goto ( jmp ) est elle une "regression" et celle d´un if ne l´est pas ?

Data:
"On" en a plus besoin. Bon deja regarde un peu les guillements pour le on, et tu lira le fond de ma pensée... C´est un reliquat d´ancien language exsitant, oui certes.. mais l´historique ne doit pas justifier les action presentes.

Mais la question posé est pourquoi se l´interdire dans certains cas ou il est elegant puisqu´il fait parti du language ? Pour clarifier le fond de ma pensé, tu a un outil ( le language ) et tu en occulte une partie, ( "le chauffage dans ma voiture ben je le mets jamais" ) au nom de la bonne pensée de certains.

Mon idée premiere dans ce topic etait d´attirer votre attention sur vos premiere reflexion "NON au GOTO", qui me semble a priori bien vindicative, et pour certains de les ammener a reflechir sur leurs regles etablies de programmations.

Pour le continue, comme c´est un element ( aussi ) du language et qu´a certaines occasions j´ai eprouvé le besoin et vu l´utilité de cette instruction, ben je l´utilise.

Merci de votre attention.

"En quoi l´utilisation d´un goto ( jmp ) est elle une "regression" et celle d´un if ne l´est pas ? "

Je te donne un exemple en français :

goto label; => aller au label.
if(condition)instr1; => si la condition est vraie, alors executer instr1.

En clair, goto est une instruction très primaire, alors que le if est plus évolué

Donc un saut inconditionnel est une instruction tres "primaire", et un saut conditionnel est une instruction evoluée . ..

La classification est interressante.

Dois je comprendre par la que:
si une instruction en C genere plus d´une instruction assembleur elle est evolué sinon elle est "primaire" ?

Peux tu classifier alors le break et le continue ?

Je ne classifierais rien d´autre. C´est assez aisé à comprendre. Mais monsieur préfère faire le sourd et se moquer.

Bon, décidément je suis trop bon. Une analogie avec le français :

utilisation du goto : "toi sentir pas bon ? moi aller très loin."

utilisation du if : "si tu sens pas bon, alors je pars très loin."

Attends 5 minutes :

1/ Je ne fais pas le sourd, je cherche a comprendre quelle est ta demarche pour ne PAS utiliser une instruction. ( Visiblement ta reponse a cela c´est dans le 2/)

2/ Tu parles d´instruction "primaire" et evoluée. C´est bien la premiere fois que j´entends parler d´un tel concept, alors je m´informe. J´espere que tu vas m´eclairer de tes lumieres, vu que c´est assez aisé a comprendre. Pasque avant de lancer de beau mots, il faut reflechir avec ta tete et po suivre Panurge...

3/ Si t´etais bon, t´aurais reussi à expliquer ton concept sans le moindre doute, et ainsi illuminer de ton infinie savoir faire . .. Mais tel n´est po le cas puisque je reviens ( encore) a la charge.

4/ Tu peux faire toutes le analogies qu´il te convient ( mais dans la derniere retire le ? et elle devient correcte ) celles ci ne repondent toujours pas a la question 1/

Le fait que tu ne comprennes pas ne veut pas dire que je suis en faute, très cher.

Si tu veux, c´est une histoire de couches de langages.
En gros, tu as :
1 - le lambda-calcul
2 - le langage machine
3 - l´assembleur
4 - les langages procéduraux ( C/Pascal/Basic...)
5 - les langages objets
etc...

"Goto" fait partie de la couche 3.
"If" fait partie de la 4.

Ca va cette fois ?

Ben non malin pasqu´il est implementé dans tous les languages proceduraux que tu enonces ! !

Soit tu est dans l´erreur, soit les implementeurs de ces languages sont dans l´erreur !
Trop facile....

Programmeur ( de metier ) neccessite 2 qualités :
1/ Comprehension technique, tout le monde semble l´avoir ici.
2/ Communication, et la ca peche un maximum...