Discussion :

[Rimidalv]

Bonjour, Comment puis-je tester l’entrée std::cin ? Il devrait être double, avec string ou istringstream? Merci

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
double xQ, yQ;
	std::cout << "Veuillez calculer le point à partir duquel la tangente est calculée sur la parabole:   " << std::endl;
	std::cout << "S’il vous plaît x: ";
	std::cin >> xQ;
	std::string str;
	std::cout << "Enter x number: ";
	std::cin >> str;
	if (isNumeric(str)) {
		std::cout << "This is a Number" << std::endl;
		xQ = static_cast<float>(str);
	}
	else
	{
		std::cout << "This is not a number";
		std::cout << "Try again: " << std::endl;
	}
 
	std::cout << std::endl;
	std::cout << "S’il vous plaît y: ";
	std::istringstream s;
	std::string stri;
	std::cin >> stri;
	s ( stri);
	s >> yQ;
	double aa, bb, cc;
 
	std::cout << std::endl;
	std::cout << "a * x^2 + b * x + c: S'il vous plait a: " << std::endl;
	std::cin >> aa;
	std::cout << std::endl;
	std::cout << "a * x^2 + b * x + c: S'il vous plait b: " << std::endl;
	std::cin >> bb;
	std::cout << std::endl;
	std::cout << "a * x^2 + b * x + c: S'il vous plait c: " << std::endl;
	std::cin >> cc;

[deedolith]

Une piste:
Tu fais toutes tes saisies dans des chaines, et tu tentes de convertir.

[Rimidalv]

Merci beaucoup deedolith, ma question est; la saisie des données doit-elle être contrôlée ? Faut-il activer les exceptions ? L'utilisateur a besoin de savoir qu'il saisit des valeurs longues*? Est-ce que if(std::cin >> xQ) peut être utilisé*? Merci tout le monde

[foetus]

La documention std::istream::operator>>, lien cplusplus.com en anglais (et std::cin, lien cplusplus.com en anglais)

En gros tu n'as rien à contrôler tu veux 1 double, tu saisies 1 variable de type double.

[dalfab]

ma question est; la saisie des données doit-elle être contrôlée ?

Ça parait être une bonne idée, c'est d'autant plus vital quand l'origine des données est douteuse, et rien n'est pire que l'humain.

Faut-il activer les exceptions ?

Pourquoi pas? Ça dépend de ton besoin. Mais les exceptions sont plus adaptées si la stratégie est : en cas d'erreur on arrête tout.

L'utilisateur a besoin de savoir qu'il saisit des valeurs longues*?

Ça dépend, on peut aussi décider de planter si quelque chose ne va pas. Mais là aussi, c'est plus sain de gérer et d'informer.

Est-ce que if(std::cin >> xQ) peut être utilisé*?

Oui. Mais il devient alors difficile de bien contrôler et d'informer l'utilisateur.
Il est plus robuste de gérer les données en 2 temps:
a) lire une ligne saisie par l'utilisateur.
b) analyser la ligne, y extraire ce dont a besoin, signaler les erreurs et recommencer si nécessaire.

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
bool  saisie_non_valide{};
double  valeur_attendue;
do {
   std::string  ligne;
   std::getline( std::cin, str );         // lire une ligne sans polluer le flux std::cin
   std::istringstream  iss{str};     // début de l'analyse
   // analyser avec iss par exemple:
   saisie_non_valide = true;
   if ( !(iss >> valeur_attendue) ) {
      endl( std::cout << "valeur numérique attendue, recommencez" );
   else if ( valeur_attendue > valeur_max  ||  valeur_attendue < valeur_min )
      endl( std::cout << "valeur numérique hors limite, recommencez" );
   else
      saisie_non_valide = false;
} while ( saisie_non_valide );

On peut encapsuler cela dans des fonctions.

[Rimidalv]

Merci pour cette réponse détaillée, vous êtes d’une grande aide, bonne nuit.

[Rimidalv]

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
bool  saisie_non_valide{};
double  valeur_attendue;
try{
 
   std::string  ligne;
   std::getline( std::cin, str );         // lire une ligne sans polluer le flux std::cin
   std::istringstream  iss{str};     // début de l'analyse
   // analyser avec iss par exemple:
   saisie_non_valide = true;
   if ( !(iss >> valeur_attendue) ) {
      endl( throw "valeur numérique attendue, recommencez" );
   else if ( valeur_attendue > valeur_max  ||  valeur_attendue < valeur_min )
      endl( throw 47 );
   else
      saisie_non_valide = false;
 
}
catch(int) {std::cout << "valeur numérique hors limite, recommencez";
}
catch(const char* message) { std::cout << message ;
}

Est-il permis de traiter les erreurs de cette façon?

[dalfab]

On peut traiter cela de cette façon.

Il manque peut-être la possibilité de reposer la question en cas d'anomalie, et ici utiliser les exceptions plutôt qu'une variable signalant l'erreur me semble inutilement complexe.

[Rimidalv]

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
template<class T>
typename std::enable_if<!std::numeric_limits<T>::is_integer, bool>::type
almost_equal(T x, T y, int ulp)
{
    // the machine epsilon has to be scaled to the magnitude of the values used
    // and multiplied by the desired precision in ULPs (units in the last place)
    return std::fabs(x - y) <= std::numeric_limits<T>::epsilon() * std::fabs(x + y) * ulp // Are we equal??
        // unless the result is subnormal
        || std::fabs(x - y) < std::numeric_limits<T>::min(); // ist unser Wert Modul oder Modulo?
}
 
int main()
{
    std::cout << std::numeric_limits<double>::epsilon() << '\n';     //    Dans le néant est un infini
    std::cout << std::numeric_limits<int>::min() << '\n';   /// Gibt es Limit? Dem Gott? Gott IT?
    double d1 = 0.2;
    double d2 = 1 / std::sqrt(5) / std::sqrt(5);
    std::cout << std::fixed << std::setprecision(20)
        << "d1=" << d1 << "\nd2=" << d2 << '\n';
 
    std::cout << " sqrt(5): " << sqrt(5) << std::endl;
 
    if (d1 == d2)
        std::cout << "d1 == d2\n";
    else
        std::cout << "d1 != d2\n";
 
    if (almost_equal(d1, d2, 2))
        std::cout << "d1 almost equals d2\n";
    else
        std::cout << "d1 does not almost equal d2\n";
}