Discussion :

[ktm26]

Bonjour,

je souhaite vérifier qu'une variable ne dépasse pas le type INT.
Je commence à étudier et programmer depuis peu ( 2 mois ).
Le petit programme que je suis occupé a réaliser permet de calculer la factorielle d'un nombre.
J'ai ajouté dans la fonction factorielle une vérification pour voir quand le résultat dépasse la valeur maximale du type int mais ça ne fonctionne pas...

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Factorielle
{
    class Program
    {
 
 
        //Fonction qui permet de vérifier si le nombre entré est bien un entier.
        public static int IsIntPos(string message)
        {
            Console.WriteLine(message);
            Console.Write("> ");
            string verifEntry = "";
            int number = 0;
            bool ok = false;
 
            while (!ok )
            {
                verifEntry = Console.ReadLine();
                ok = int.TryParse(verifEntry, out number);
                if (ok == false )
                {
                    Console.WriteLine("Veuillez introduire un nombre entier uniquement svp !");
 
                }
                else if (number < 0)
                {
                    Console.WriteLine("Veuillez introduire une valeur positive svp !");
                    ok = false;
                }
            }
            return number;
 
        }
 
        //Fontion qui permet de calculer la factorielle d'un nombre entier.
        public static int Factorielle(int nombre)
 
        {
 
 
            int resultat = 1;
 
 
            for (int i = 1; i <= nombre; i++)
            {
                if (resultat > int.MaxValue)
                {
                    Console.WriteLine("Ne rentre pas dans un INT");
                }
                else
                {
                    resultat = i * resultat;
                }
            }
 
                return resultat;
 
 
 
 
 
 
        }
 
 
        static void Main(string[] args)
        {
 
 
            int nombreChoisi = IsIntPos("Introduire un nombre entier pour connaitre la factorielle de ce nombre");
            int resultatFactorelle = Factorielle(nombreChoisi);
 
 
                Console.WriteLine("La factorielle du nombre {0} est {1} . ", nombreChoisi, resultatFactorelle);
 
 
 
 
 
            Console.ReadKey();
 
 
        }
    }
}

Au passage si c'est mal écrit j'attends vos avis je débute ..
Merci pour votre aide.

[jopopmk]

Salut,

la fonction TryParse te retournera false si ça rentre pas. Si tu veux distinguer l'échec sur un nombre trop grand d'une saisie non numérique, tu peux utiliser la fonction Parse et tu catches les exceptions. Si tu tombes sur une OverflowException c'est que t'essaies d'en mettre de trop.

Bon dev.

[J@ckHerror]

Bonjour,

Je n'ai jamais eu à faire ce genre de chose, mais j'ai l'impression qu'il y a un truc pas logique
Tu test si ta variable resultat dépasse la capacité d'un int, alors que resultat à été déclaré comme int.... c'est donc forcément impossible qu'elle dépasse sa propre limite !
C'est comme si tu prenais une voiture qui à une vitesse max connue de 200Km/h et que tu t'acharnais à la faire passer à fond devant un radar pour la flasher à 220km/h ...

Ce que je ferais c'est par exemple de déclarer dans ta méthode Factorielle une variable resultatLong de type long pour recevoir le résultat de ta multiplication, puis de tester si cette varaible long est supérieur à du int ...

Bon code,
J@ck.

[ktm26]

ok , merci beaucoup a vous 2 pour l'aide et la rapidité !

Je vais essayer cela ce soir.

Bonne soirée

[nouanda]

Par défaut, tu n'auras pas d'erreur d'overflow.
En revanche, puisque les int32 sont signés, tu "boucleras" entre le maximum et le minimum.
Pour un int32, ajouter 1 à la valeur max 2,147,483,647 retourne -2,147,483,648. (inversement, retrancher 1 à -2,147,483,648 retourne 2,147,483,647).

Tu peux forcer la vérification en utilisant la méthode checked.
checked(2147483647 + 1) retournera une OverflowException que tu peux intercepter.

Tu peux par exemple modifier ta boucle:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
            for (int i = 1; i <= nombre; i++)
            {
                try
                {
                    resultat = checked(i * resultat);
                }
                catch (System.OverflowException ex)
                {
                    Console.WriteLine("Attention, dépassement de capacité");
                }
            }

[ktm26]

Merci pour ta réponse nouanda. En effet je n'avais pas d'erreur overflow. Quand je mettais un nombre dont le résultat dépassait un int, j'obtenais 0 en résultat. Je n'ai pas encore étudié les exceptions. Je vais essayer ce code et comprendre comment ça fonctionne.
En attendant, je suis arrivé à une solution qui fonctionne. Voici ce que j'ai fait ( je retourne -1 dans la méthode factorielle a partir du moment ou le résultat dépasse int.maxValue / i et ensuite je gère ce défaut dans le Main() )
Je ne sais pas si c'est bien de faire comme ça, mais ça à l'air de bien fonctionner. Des avis?

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Factorielle
{
    class Program
    {
 
 
        //Fonction qui permet de vérifier si le nombre entré est bien un entier.
        public static int IsIntPos(string message)
        {
            Console.WriteLine(message);
            Console.Write("> ");
            string verifEntry = ""; 
            int number = 0;
            bool ok = false;
 
            while (!ok )
            {
                verifEntry = Console.ReadLine();
                ok = int.TryParse(verifEntry, out number);
                if (ok == false )
                {
                    Console.WriteLine("Veuillez introduire un nombre entier uniquement svp !");
 
                }
                else if (number < 0)
                {
                    Console.WriteLine("Veuillez introduire une valeur positive svp !");
                    ok = false;
                }
            }
            return number;
 
        }
 
        //Fontion qui permet de calculer la factorielle d'un nombre entier.
        public static int Factorial(int nombre)
 
        {
            int result = 1;
            for (int i = 1; i <= nombre; i++)
            {
                if (result > int.MaxValue/i)
                {
                    return -1;        
                }
                else
                {
                    result = i * result;
                }
            }
 
            return result;
        }
 
 
        static void Main(string[] args)
        {
            bool exeedsInt = false;
 
             while (!exeedsInt)
 
            {
                int selectedNumber= IsIntPos("Introduire un nombre entier pour connaitre la factorielle de ce nombre");
                int factorialResult = Factorial(selectedNumber);
                if (factorialResult == -1)
                {
                    exeedsInt = false;
                    Console.WriteLine("Le résultat de la valeur introduite dépasse la valeur maximale d'un entier de type int ({0}).", int.MaxValue);
                }
                else
                {
                    Console.WriteLine("La factorielle du nombre {0} est {1} . ", selectedNumber, factorialResult);
                    exeedsInt = true;
                }
 
            }
 
            Console.ReadKey();
 
 
        }
    }
}

Au passage, si quelqu'un à une idée d'exercice pour compléter ce code, je suis preneur. N'oubliez pas que je débute

[jopopmk]

Re,

le nombre inconnu, c'est le petit jeu qui se code en mode console qu'on fait toujours faire aux débutants
L'appli tire un chiffre au hasard et l'utilisateur doit le trouver. Il fait une proposition de valeur, si c'est la bonne c'est la victoire, sinon l'appli dit à l'utilisateur si la valeur à trouver est plus grande ou plus petite que la valeur saisie, et ça boucle jusqu'à ce que l'utilisateur trouve ou qu'un nombre maximum de tentatives est atteint.