Vérifier qu'une variable ne dépasse pas le type INT

Version imprimable

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:

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.

14/03/2017, 15h57
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.
14/03/2017, 16h03
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 :roll:
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 :aie: !
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 ... :weird:

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.
14/03/2017, 18h22
ktm26

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

Je vais essayer cela ce soir.

Bonne soirée

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:

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é"); } }

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:

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

15/03/2017, 09h00
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.

Voila, j'ai réalisé le jeu du nombre inconnu. Je suis arrivé a quelque chose de fonctionnel.

Est ce que quelqu'un sait regarder si le code est bien écrit? Ou si certaines choses ne se font pas comme ça...

Code:

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace ConsoleApplication6
{
    class Program
    {
        static int RandomNumber(int min, int max)
        {
            Random random = new Random((int)DateTime.Now.Ticks);
            return random.Next(min, max);
        }
        public static int IsInt(string message)
        {
            string verifEntry = "";
            int number = 0;
            bool ok = false;
 
            while (!ok)
            {
                Console.WriteLine(message);
                Console.Write("\n> ");
                verifEntry = Console.ReadLine();
                ok = int.TryParse(verifEntry, out number);
                if (ok == false)
                {
                    Console.WriteLine("\nMauvaise manipulation ! Entrez un nombre uniquement S.V.P. ! ");
                }
                else
                {
                    ok = true;
                }
            }
            return number;
        }
        static void Main(string[] args)
        {
            Console.WriteLine("====Jeu du plus ou moins====\n");
            bool continuer = false;
            string ouiNon = "";
            while (!continuer)
            {
                Console.WriteLine("L'ordinateur choisi un nombre au hazard entre 0 et 100...\n");
                int secretValue = RandomNumber(0, 100);
                bool gameOver = false;
 
                for (int i = 0; i < 45; i++)
                {
                    Console.Write(".");
                    Thread.Sleep(50);
                }
                Console.WriteLine("\n\nVoila ! A vous de deviner ce nombre !\n");
                while (!gameOver)
                {
                    int entryValue = IsInt("\nIntroduisez un nombre");
 
                    if (entryValue == secretValue)
                    {
                        Console.WriteLine("\nBravo !!! Le nombre mystère était bien le {0}", secretValue);
                        gameOver = true;
                        break;
                    }
                    else if (entryValue < secretValue)
                    {
                        if (entryValue < 0)
                        {
                            Console.WriteLine("\nLe nombre introduit n'est pas compris entre O et 100 ! ");
                        }
                        else
                        {
                            Console.WriteLine("\nLe nombre mystère est plus grand que {0}", entryValue);
                        }
                    }
                    else
                    {
                        if (entryValue > 100)
                        {
                            Console.WriteLine("\nLe nombre introduit n'est pas compris entre O et 100 ! ");
                        }
                        else
                        {
                            Console.WriteLine("\nLe nombre mystère est plus petit que {0}", entryValue); ;
                        }
                    }
                }
 
                Console.WriteLine("\nVoulez-vous continuer? Introduisez O pour oui ou N pour non : ");
                bool ok = false;
                while (!ok)
                {
                    Console.Write("\n>");
                    ouiNon = Console.ReadLine();
 
                    if (ouiNon == "O" || ouiNon == "o")
                    {
                        ok = true;
                        continuer = false;
                        Console.WriteLine("\nOn continue...\n");
                        Thread.Sleep(3000);
 
                    }
                    else if (ouiNon == "N" || ouiNon == "n")
                    {
                        ok = true;
                        continuer = true;
 
                    }
                    else
                    {
                        Console.WriteLine("\nRépondez uniquement par O pour oui ou par N pour non svp !");
                        ok = false;
                    }
 
                }
            }
            Console.WriteLine("\nAppuyez sur une touche pour quitter le programme");
            Console.ReadKey();
        }
    }
}

merci et bon week end ;)

20/03/2017, 14h29
jopopmk

Re,

quelques remarques (j'ai pas testé le code) :
- tu n'as pas besoin d'instancier un nouveau Random à chaque demande de nombre aléatoire,
- il faut choisir entre anglais et français pour tes noms de variables/fonctions,
- perso, j'aurais tout fait dans le Main, et avec une seule boucle infinie.

Bonne semaine et bonne continuation dans ton apprentissage :)
23/03/2017, 11h45
Noxen
while(!continuer) { : cette sémantique ne me paraît pas très logique, on attendrait plutôt : while(continuer) {.

Ta fonction IsInt peut s'écrire de façon plus concise, mais ça viendra avec l'habitude :
Code:

1 2 3 int number; Console.WriteLine("Saisissez un nombre"); while(!int.TryParse(Console.ReadLine(), out number)) Console.WriteLine("La valeur saisie n'est pas un nombre. Recommencez s'il-vous-plaît :");
Tu peux éviter if(ouiNon == "O" || ouiNon == "o") { avec if(ouiNon.ToLower() == "o") {.