Discussion :

[Hobbèse]

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 :

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

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 !

[Sve@r]

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 c :

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

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...

[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 :



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)).

[Sve@r]

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

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...

[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)

[Hobbèse]

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

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.

[Sve@r]

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)

[ternel]

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

[Hobbèse]

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 :

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
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à !

[plume13]

Hello,

Comme tu nous présente ton code pour que l'on fasse des commentaires, j'en profite
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 (même quand on a plus d'expérience, on le fait, alors...)

[Sve@r]

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 :

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
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...

[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.

[Hobbèse]

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

Merci pour vos réponses en tout cas.

Voici mon code :

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
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
 
}

[jlliagre]

Un peu mieux mais:

Code :

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

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 :

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

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.

[Hobbèse]

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