Discussion :

[00-Pegasus-00]

Bonjour, j'ai un problème avec une boucle FOR en C++

je veux incrementer des variables de 0.5 à 6(exclu) comme suit : {0.5 0.6 0.7 0.8 0.9 1 2 3 4 5 } avec une boucle for
donc pour les chiffres < 1 un pas de 0.1
et un pas de 1 pour le schiffres de 1 à 6

par exemple si nb1 = 0.9 et nb2 = 2 j'e devrait avoir {0.9 et 1} soit 2 boucles

Comment faire ???

voici mon debut de 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
 
#include <iostream>
#include <iomanip> // pour setprecision()
using namespace std;
 
int main()
{
  // Réduire le format d'affichage
  cout << setprecision(4);
 
  // Paramètres
 
	double debut_for =0;
	double fin_for =0;
 
	cout << " Saisir nb1 ? (entre 0.5 et 6) ? " <<endl;;
	cin >> debut_for;
 
	cout << " Saisir nb2 ? (entre nb1 et 6) ? " <<endl;;
	cin >> fin_for;
 
 
		for (debut_for ; debut_for < fin_for ; ++debut_for) 
		{
		cout << debut_for <<endl;
		}
 
 
 
 
      /*******************************************
   * Ne rien modifier après cette ligne.
   *******************************************/
 
  return 0;
}

qui ne fonctionne pas evidemment..


merci d'avance pour ceux qui peuvent me depanner...

[CGi]

soit 2 boucles

C'est bien ça, deux boucles.
La première pour les valeur inférieur à 1 et la deuxième pour celle supérieur ou égal à 1

La boucle for :
for(initialisation; condition; expression)
La zone initialisation sert à initialiser une variable, toi tu n'initialises rien du tout (tu mets juste le nom de la variable).
Dans ton cas la variable est déjà initialisée lors de la saisie (cin) donc tu ne mets rien du tout.

[dalfab]

Oui deux boucles;

Tu peux aussi avoir une unique boucle avec le pas d'avancée qui change.

Dans les deux cas, il y a un risque potentiel : est-ce que 0.5 plus 5 fois 0.1 fait exactement 1.0? C'est loin d'être sûr!
D'où l'exemple douteux:

Code :

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

1
2
3
4
5
6
double  pas = 0.1;
for ( double nb = debut_for ; nb <= fin_for ; nb += pas ) {
    if ( nb >= 1.0 )  // mais ce test n'est pas fiable!! (après 0.99999999 il devrait y avoir 2.0)
        pas = 1.0;    // pour tout ce qui est supérieur à 1.0 c'est un pas de 1.0
    std::cout << nb << ' ';
}

[koala01]

Salut,

Oui deux boucles;

Tu peux aussi avoir une unique boucle avec le pas d'avancée qui change.

Dans les deux cas, il y a un risque potentiel : est-ce que 0.5 plus 5 fois 0.1 fait exactement 1.0? C'est loin d'être sûr!
D'où l'exemple douteux:

Code :

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

1
2
3
4
5
6
7
 
double  pas = 0.1;
for ( double nb = debut_for ; nb <= fin_for ; nb += pas ) {
    if ( nb >= 1.0 )  // mais ce test n'est pas fiable!! (après 0.99999999 il devrait y avoir 2.0)
        pas = 1.0;    // pour tout ce qui est supérieur à 1.0 c'est un pas de 1.0
    std::cout << nb << ' ';
}

Dans les deux cas, il y a un risque potentiel : est-ce que 0.5 plus 5 fois 0.1 fait exactement 1.0? C'est loin d'être sûr!

Ceci étant dit, il y a quand même une alternative potentielle dans le fait de travailler avec des entiers "le plus longtemps possible". Je m'explique:

Au lieu de partir avec des valeurs réelles comprises entre 0.1 et 1 (par pas de 0.1) d'une part et des valeurs entières comprises entre 1 et 5 (par pas de 1) de l'autre, rien n'empêche de baser la logique sur des valeurs ... entières dix fois supérieures.

Nous baserions donc cette logique sur des valeurs comprises entre 1 et 10 (par pas de 1) pour la première partie et entre 10 et 50 (par pas de 10) pour la deuxième et nous ferions le "calcul final" -- à savoir la division par 10 (avec conversion en réel au passage) qu'une fois que ... cette valeur finale est nécessaire.
Cela pourrait prendre une forme proche de

Code :

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

1
2
3
4
5
6
7
 int step{1};
    for(int i = 1; i<=50; i+=step){
        if(i==10)
            step=10;
        double value = static_cast<double>(i)/10.;
        std::cout<<value <<" ";
    }

Cela aurait -- au moins -- l'avantage d'éviter les problèmes liés à la comparaison de réels et à leur imprécision potentielle

[Guesset]

Bonjour,

Pour éviter toute incertitude sur le comportement du cumul des erreurs en flottants, il y a une solution simple. Ne pas en avoir. Ici c'est simple car finalement c'est une boucle entière de 1/10 .

On peut donc écrire un truc du genre :

Code C++ :

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
#include <iostream>
#include <iomanip>                               // Pour setprecision()
using namespace std;
 
int main() {
   cout << setprecision(4);                      // Réduire le format d'affichage
   double debut_for = 0.0, fin_for = 0.0;
   cout << " Saisir nb1 ? (entre 0.5 et 6) ? " << endl;
   cin >> debut_for;
   cout << " Saisir nb2 ? (entre nb1 et 6) ? " << endl;
   cin >> fin_for;
   int isup = static_cast<int>(fin * 10.0), di = 5;
   for(int i = static_cast<int>(debut_for * 10.0); i < isup ; i += di) {
      cout << i * 0.1 << endl;
      if(i == 10) di = 10;
   }
   return 0;
}

Si on a le moindre doute sur la conversion en entier qui pourrait avoir le même type de problème, il suffit de remplacer 10.0 par 10.0001 pour être certain que le résultat entier ne soit jamais inférieur avec ce qu'il devrait être sans pour autant risquer une surévaluation.

Remarque : les entrées sont limitées mais ces limitations ne sont pas contrôlées.

Salutations

[00-Pegasus-00]

Messieurs,

Merci pour toutes vos réponses, c'est très enrichissant et j'ai appris des choses...

Je met en résolu...