#include <iostream>
#include <string>

using namespace std;

int main()
{
    int a(0);
    string question;
    cout << "Hello world!" << endl;

    do
    {
        cin >> question;

    }while (a >= 1);
    return 0;
}

Voici mon début de programme mais il y a un problème, quand j'execute le programme, dès que j'écris quelque chose, le programme s'arrête comme si la valeur de a avait été changé mais je ne l'ai pas changé. Merci de votre future aide!!

-
Edité par OlivierLebel2004 25 mars 2019 à 23:24:58

Ton a est égal à 0. Tu continues tant que a est plus grand que 1.

exactement mais quand j'execute le programme, la boucle ne se fait pas. J'écris qu'elque chose et sa fait comme directement le return 0

Bah oui, a n'est jamais plus grand ou égal à 1, pourquoi y aurait-il une boucle ?

Salut,

Il faut se méfier énormément de la traduction francaise des termes utilisés pour représenter les boucles, car on désigera une boucle prenant la forme de

while (condition){

}

sous le terme de "boucle tant que"(la condition est remplie) et une boucle prenant la forme de

do{

} while(condition);

sous le terme d'une boucle "jusque"(la condition soit remplie).

Du coup, lorsque l'on exprime ce genre de boucle en francais, on va indiquer la condition qui permettra de sortir de la boucle (je veux rentrer dans la boucle jusqu'à ce que a soit plus grand ou égal à 1, alors que je sais qu'il vaut 0 au début du programme).

Malheureusement, le langage ne voit pas les choses de cette manière, car la boucle do ... while n'est jamais qu'un adaptation de la boucle while (il est -- sommes toutes -- très simple de transformer une boucle while en boucle do ... while, et inversement ), et qu'elle en respecte les mêmes règles: la condition que l'on indique entre parenthèse représente la condition qui permet ... d'entrer "une fois de plus" dans la boucle.

Si tu veux entrer plusieurs fois dans une boucle do... while en t'assurant que tu y entrera jusqu'à ce qu'une variable -- qui vaut 0 au départ -- soit différente de 0 (ce qui est encore différent de "plus grand ou égal à 1", car ... -1 est aussi différent de 0 ), tu dois indiquer la condition qui permettra de rentrer dans la boucle, à savoir, que la variable doit être égale à 0

Et si tu considère que tu dois aussi rentre "une fois de plus" si ta variable vaut -1 (ou -41, bref, aussi longtemps que la variable n'est pas "plus grande ou égale à 1"), tu dois bel et bien indiquer dans ta condition qu'elle doit être ... plus petit que 1.

-
Edité par koala01 26 mars 2019 à 11:50:48

OlivierLebel2004 a écrit:

#include <iostream>
#include <string>

using namespace std;

int main()
{
    int a(0);
    string question;
    cout << "Hello world!" << endl;

    do
    {
        cin >> question;

    }while (a >= 1);
    return 0;
}

Voici mon début de programme mais il y a un problème, quand j'execute le programme, dès que j'écris quelque chose, le programme s'arrête comme si la valeur de a avait été changé mais je ne l'ai pas changé. Merci de votre future aide!!

-
Edité par OlivierLebel2004 il y a environ 12 heures

Tu as initialisé a à 0 et sa valeur ne change pas dans ton programme, donc ta boucle while ( a>=1) va s'exécuter éternellement...le bug est plutôt normal.

En même temps pourquoi tu fais un programme aussi tordu?

-
Edité par Asmitta 26 mars 2019 à 12:26:57

OlivierLebel2004 a écrit:

#include <iostream>
#include <string>

using namespace std;

int main()
{
    int a(0);
    string question;
    cout << "Hello world!" << endl;

    do
    {
        cin >> question;

    }while (a >= 1);
    return 0;
}

Voici mon début de programme mais il y a un problème, quand j'execute le programme, dès que j'écris quelque chose, le programme s'arrête comme si la valeur de a avait été changé mais je ne l'ai pas changé. Merci de votre future aide!!

-
Edité par OlivierLebel2004 il y a environ 12 heures

Tu as initialisé a à 0 et sa valeur ne change pas dans ton programme, donc ta boucle while ( a>=1) va s'exécuter éternellement...le bug est plutôt normal.

Eternellement non, une unique fois, oui.

-
Edité par Didy7 26 mars 2019 à 13:17:52

Didy7 a écrit:

BrayanTiwa a écrit:

OlivierLebel2004 a écrit:

#include <iostream>
#include <string>

using namespace std;

int main()
{
    int a(0);
    string question;
    cout << "Hello world!" << endl;

    do
    {
        cin >> question;

    }while (a >= 1);
    return 0;
}

Voici mon début de programme mais il y a un problème, quand j'execute le programme, dès que j'écris quelque chose, le programme s'arrête comme si la valeur de a avait été changé mais je ne l'ai pas changé. Merci de votre future aide!!

-
Edité par OlivierLebel2004 il y a environ 12 heures

Tu as initialisé a à 0 et sa valeur ne change pas dans ton programme, donc ta boucle while ( a>=1) va s'exécuter éternellement...le bug est plutôt normal.

Eternellement non, une unique fois, oui.

-
Edité par Didy7 il y a environ 8 heures

Je pense pas, une boucle while s'exécute jusqu'à ce que la condition n'est plus. Mais dans son code a ne va jamais être supérieur à 1 puisque ça a été initialisé à 0 et sa valeur n'est pas modifier aucours de l'exécution du programme. 

Même si son programme à l'air correct, faut qu'il change soit sa condition, soit l'instruction dans while

(C'est ce que je pense...)

> une boucle while s'exécute jusqu'à ce que la condition n'est plus [...] > a ne va jamais être supérieur à 1 puisque ça a été initialisé à 0

Si cela n'est pas une condition à false, qu'est-ce ?

BrayanTiwa a écrit:

Je pense pas, une boucle while s'exécute jusqu'à ce que la condition n'est plus. Mais dans son code a ne va jamais être supérieur à 1 puisque ça a été initialisé à 0 et sa valeur n'est pas modifier aucours de l'exécution du programme. 

Même si son programme à l'air correct, faut qu'il change soit sa condition, soit l'instruction dans while

(C'est ce que je pense...)

koala01 a écrit:

Salut,

Il faut se méfier énormément de la traduction francaise des termes utilisés pour représenter les boucles, car on désigera une boucle prenant la forme de

while (condition){

}

sous le terme de "boucle tant que"(la condition est remplie) et une boucle prenant la forme de

do{

} while(condition);

sous le terme d'une boucle "jusque"(la condition soit remplie).

Du coup, lorsque l'on exprime ce genre de boucle en francais, on va indiquer la condition qui permettra de sortir de la boucle (je veux rentrer dans la boucle jusqu'à ce que a soit plus grand ou égal à 1, alors que je sais qu'il vaut 0 au début du programme).

Malheureusement, le langage ne voit pas les choses de cette manière, car la boucle do ... while n'est jamais qu'un adaptation de la boucle while (il est -- sommes toutes -- très simple de transformer une boucle while en boucle do ... while, et inversement ), et qu'elle en respecte les mêmes règles: la condition que l'on indique entre parenthèse représente la condition qui permet ... d'entrer "une fois de plus" dans la boucle.

Si tu veux entrer plusieurs fois dans une boucle do... while en t'assurant que tu y entrera jusqu'à ce qu'une variable -- qui vaut 0 au départ -- soit différente de 0 (ce qui est encore différent de "plus grand ou égal à 1", car ... -1 est aussi différent de 0 ), tu dois indiquer la condition qui permettra de rentrer dans la boucle, à savoir, que la variable doit être égale à 0

Et si tu considère que tu dois aussi rentre "une fois de plus" si ta variable vaut -1 (ou -41, bref, aussi longtemps que la variable n'est pas "plus grande ou égale à 1"), tu dois bel et bien indiquer dans ta condition qu'elle doit être ... plus petit que 1.

-
Edité par koala01 il y a environ 21 heures