Poursuivre l'exécution d'une boucle while()

Version imprimable

Bonjour,

Je suis nouveau ici ainsi que dans le monde de la programmation. ;)

Après de multiples recherches, y compris naturellement sur ce forum, je ne trouve pas la réponse à ma question.

Le problème n'a rien de complexe, et je pense que quelqu'un avec plus d'expérience que moi pourra m'aider.

J'ai une fonction qui remplit parfaitement son rôle (je ne rencontre pas d'erreur et elle produit le type de résultat escompté).

Dans cette fonction, j'ai une boucle while() et j'aimerais qu'elle poursuive son exécution même après avoir produit un résultat.

J'ai vérifié, il est possible de produire plusieurs résultats avec les critères utilisés. Ce n'est donc pas qu'il n'y a qu'un résultat.

Voici le code réduit à l'essentiel :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 while (tests logiques) { for (x=0; x< y; x++) { (produit des résultats pour le test logique) } for (x=0; x< y; x++) { (manipule les résultats précédents) } }
J'ai essayé d'utiliser continue; en vain. Cela n'a aucun effet.

Merci par avance pour votre réponse ! :ccool:

Salut

Qu'entends-tu par "produire des résultats" ???
En programmation, il n'y a que des variables et des instructions. Si tu veux que la seconde boucle for() puisse traiter les résultats produits par la première, il te faut alors sauvegarder ces résultats dans une variable adaptée => un tableau. Ainsi la seconde boucle pourra accéder aux informations sauvegardées dans la première.

Ca donnera un truc de ce style
Code:

1 2 3 4 5 6 7 8 9 10 11 12 déclaration tab[y] while (tests logiques) { for (x=0; x< y; x++) { calculer le résultat x et le stocker dans tab[x] } for (x=0; x< y; x++) { traiter la valeur stockée dans tab[x] } }
Toutefois, à ce niveau minimaliste, le tableau devient inutile car on peut traiter directement le résultat x dans la première boucle sans le stocker. Mais c'était pour donner un cadre général...

28/01/2014, 23h32
Hobbèse

Tout d'abord, merci pour cette réponse (rapide !).

Sur le premier point (vocabulaire), je tiens à présenter mes excuses d'être aussi imprécis : je débute tout juste la programmation. Je vais tâcher de veiller à mon langage.

Sur le second point : la difficulté n'est pas là. Mes boucles for() interagissent bien ensemble grâce à malloc. Mon problème est, comme je l'ai exposé, que l'instruction s'arrête dès qu'un résultat est trouvé. Or je voudrais avoir tous les résultats possibles.

Merci encore !

Edit.

Je cherche à faire ceci :

http://upload.wikimedia.org/wikipedi...op-diagram.svg

Tant que A est TRUE, poursuivre jusqu'à ce que A soit FALSE.
Mais mon while() est construit à l'envers, car mon A est FALSE jusqu'à ce qu'il soit TRUE (sous-entendu : tant que ces conditions logiques produisent FALSE, continuer de chercher pour qu'elles soient TRUE).

Ainsi, imaginons que je veuille que (a == b), je fais : while(!(a==b)).
28/01/2014, 23h52
Sve@r

Citation:

Envoyé par Hobbèse

Ainsi, imaginons que je veuille que (a == b), je fais : while(!(a==b)).

Oui c'est un choix. Ou alors tu écris plus simplement while (a != b) car tu as à ta disposition tous les opérateurs logiques ainsi que leurs inverses.
Et en faisant attention, dans le cas de tests plus complexes, aux lois de De Morgan ; qui disent que non(A et B) = non(A) ou non(B) et que non(A ou B) = non(A) et non(B).
Ainsi si tu veux un nombre compris entre X et Y (donc plus grand que X et plus petit que Y) alors tu ne veux pas de nombre plus petit que X ou plus grand que Y

Citation:

Envoyé par Hobbèse

Mes boucles for() interagissent bien ensemble grâce à malloc.

Euh oui ce n'est pas trop le rôle de malloc() que de faire intéragir des boucles for mais si ça fonctionne...:aie:
28/01/2014, 23h57
Hobbèse

J'utilise malloc dans un contexte plus large (génération de matrices dynamiques). Mais je n'avais pas songé que cela pouvait expliquer que mon while() s'arrête après un seul résultat...

Cela ne vient-il pas de la structure même du code ? (un while avec des tests logiques FALSE + deux sous-boucles for non imbriquées)
29/01/2014, 01h10
Hobbèse

C'est bon, j'ai résolu tout seul mon problème. :D

J'ai mis mes deux for dans une boucle do / while. Je peux même ajuster le nombre de résultats souhaités dans while !

Si cette solution vous intéresse, je peux vous la présenter ici avec plus de détail à votre demande.
29/01/2014, 09h45
Sve@r

Citation:

Envoyé par Hobbèse

J'utilise malloc dans un contexte plus large (génération de matrices dynamiques). Mais je n'avais pas songé que cela pouvait expliquer que mon while() s'arrête après un seul résultat...

Non. Le malloc() ne joue en rien dans l'arrêt de ta boucle. La boucle sort lorsque l'expression logique invoquée renvoie Faux. Si l'expression logique demande une égalité alors la boucle s'arrête quand l'égalité devient fausse (inégale donc) ; et si l'expression logique demande une inégalité alors la boucle s'arrête quand l'inégalité devient fausse (égale donc).

Le malloc, lui, ne fait que demander à l'OS une zone mémoire de n octets et te renvoie l'adresse du début de cette zone. Utile pour générer des matrices dynamiques oui mais n'influe pas dans un while (sauf si tu utilises sa valeur renvoyée dans l'expression logique bien évidemment)
29/01/2014, 09h48
ternel

Ca serait pas mal pour toi, nous pourrions ainsi te donner nos avis sur ta solution.

[Résolu] Explications ici

EDIT. Code erroné. Se reporter plus bas.

Bien sûr, et cela pourra être utile à d'autres.

Ma problématique, pour rappel : exécuter une instruction jusqu'à ce que des tests logiques soient TRUE, et poursuivre la recherche de résultats (dont on ne connaît pas le nombre) jusqu'à un certain nombre de recherches.

Ma solution :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int main(){
do {
            int i=0; // Initialisation nb d'essais
             for (test 1){
               }
             for (test 2){
               }
      if (tests logiques formulés négativement : “a!=b” si on veut “a==b” par ex.){
      i++; // Incrémentation nb d'essais
      continue; // Si FALSE, il faut continuer les computations
               }        
      else{ // Si TRUE, on traite les données ici jusqu'à limite du nb d'essais 
      }
 } // boucle do fermée ici
while(i=n); // n = nombre d'essais, on peut mettre i=0 pour ne pas fixer de limite
}

Et voilà !

29/01/2014, 15h08
plume13

Hello,

Comme tu nous présente ton code pour que l'on fasse des commentaires, j'en profite :mrgreen:
Outre le fait que je pense que ta condition while est incorrecte (while (i=n) est toujours vrai car on remplit i avec la valeur de n), j'ai beau relire le code, je ne comprends pas ce que tu cherches à faire.
Pour moi, c'est que le code peut être amélioré : une meilleure lisibilité du code implique une meilleure compréhension pour ceux qui auraient à le relire (y compris toi dans quelque temps), ce qui implique qu'on évite des corrections hasardeuses futures parce que l'on ne comprends plus ce qui est fait.

Je me permets de te donner ce conseil car tu as dit que tu débutais, et que je sais que ce n'est pas facile de le faire seul, on a toujours tendance à partir dans des délires :mouarf: (même quand on a plus d'expérience, on le fait, alors...)

Citation:
Envoyé par Hobbèse
Bien sûr, et cela pourra être utile à d'autres.

Ma problématique, pour rappel : exécuter une instruction jusqu'à ce que des tests logiques soient TRUE, et poursuivre la recherche de résultats (dont on ne connaît pas le nombre) jusqu'à un certain nombre de recherches.

Ma solution :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int main(){ do { int i=0; // Initialisation nb d'essais for (test 1){ } for (test 2){ } if (tests logiques formulés négativement : “a!=b” si on veut “a==b” par ex.){ i++; // Incrémentation nb d'essais continue; // Si FALSE, il faut continuer les computations } else{ // Si TRUE, on traite les données ici jusqu'à limite du nb d'essais } } // boucle do fermée ici while(i=n); // n = nombre d'essais, on peut mettre i=0 pour ne pas fixer de limite }
Et voilà !
Le continue est de trop. Si le test a renvoyé vrai alors effectivement tu incrémentes i sinon tu ne l'incrémentes pas mais tu laisses le while() vérifier si i atteint n. Accessoirement le while continuant tant que l'expression est vraie, et toi voulant (probablement) que ça continue tant que i n'a pas atteint n, je pense que tu devrais écrire while (i < n).

Et attention quand tu testes une égalité, c'est "==" qu'il faut écrire car "=" représente une affectation...

29/01/2014, 17h00
jlliagre

Deux autres remarques, l'indentation est catastrophique et la variable i ne vaudra jamais autre chose que 0, puisqu'elle est initialisée à l'interieur de la boucle et remise à 0 aussitôt après avoir été incrémentée.

Je suis affreusement désolé, j'ai répondu trop vite en composant le code de mémoire et ai commis des erreurs. :aie:

Merci pour vos réponses en tout cas.

Voici mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
 
    int i=1;
 
    do
    {
 
 
        for () 
        {
 
        }
 
 
        for ()
        {
 
        }            i++;
 
 
        if (tests logiques formulés négativement)
        {
            continue;
        }
 
        else
        {
            // Les résultats
            continue;
 
            }
 
 
    }
 
    while(i < n); // n = nb essais, ou != 0 pour un traitement indéfini
 
}

Un peu mieux mais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
        if (tests logiques formulés négativement)
        {
            continue;
        }
 
        else
        {
            // Les résultats
            continue;
 
            }
}
while(i < n);

est strictement équivalent à:

Code:

1
2
3
4
5
6
        if (tests logiques)
        {
            // Les résultats
        }
}
while(i < n);

En gros, les "continue" ne servent à rien, et le test "à l'envers" non plus.

01/02/2014, 00h31
Hobbèse

C'est très judicieux. Je prends bien compte de cette remarque. Merci !:ccool: