פונקציה נחמדה שכתבתי לקליטה בטוחה של מספר שלם מהמשתמש

הפונקציה כתובה כאן ב-#C, אבל תוכלו להמיר אותה עם קצת מחשבה לכל שפה.
אגב, בחלק מהתוכניות בבלוג כבר עשינו בה שימוש.

קליטה בטוחה של מספר int מהמשתמש:

תיאור: פונקציות לקליטת מספר שלם אחד או יותר מהמשתמש באופן בטוח.
במקרה שהמשתמש הזין קלט לא תקין, (כגון: אותיות, מינוס במקום לא נכון, יותר או פחות מספרים מהנחוץ, לא הכניס שום קלט, מספרים ארוכים מדי, מספרים שחורגים מערכי המינימום והמקסימום וכו'), הוא יתבקש להזין מחדש את הקלט עד לקבלת קלט תקין.

הערה: הפונקציה Get_Save_int_Number_From_User נכתבה במקור עבור שפת C, כנראה תמצאו בה דברים שאפשר לקצר באמצעות #C.
בניגוד אליה, הפונקציה Get_Save_int_Numbers_From_User נכתבה ישירות עבור #C.







- זו המחלקה שיש להוסיף לתוכנית שלכם:

    class UsefulTools
    {
        public static bool IsDigit(char c)
        {
            if (c <= '9' && c >= '0') return true;
            return false;
        }
        public static bool IsSpaceOrTab(char c)
        {
            if (c == ' ' || c == '\t') return true;
            return false;
        }
 
        public static int Get_Save_int_Number_From_User(String str, int min = 99999, int max = -99999)
        {
            //
            // פונקציה מעולה לטיפול בבעיות הקטנות שבקליטת מספרים לא חוקיים מהמשתמש
            //  int אפשר להעתיק את הפונקציה הזו ולעשות בה שימוש בהרבה מאוד תוכניות לקליטה בטוחה של מספר
 
 
 
            int number, i, len, minusFlag;
            char[] tmpS;
 
 
            do
            {
                minusFlag = 0;
                Console.WriteLine(str);
                tmpS = Console.ReadLine().ToCharArray();
                len = tmpS.Length;
 
                if (len > 10 || len == 0) continue; // שלא יהיה מספר עם יותר מ10 ספרות, או מספר ריק 
 
 
                // (בדיקה שכל המחרוזת מכילה רק ספרות (או מינוס בהתחלה
                if ((tmpS[0] > '9' || tmpS[0] < '0') && tmpS[0] != '-') continue; // בדיקה יחודית להתחלה בגלל האפשרות שיש מינוס
                for (i = 1; i < len; i++)
                    if (tmpS[i] > '9' || tmpS[i] < '0')
                        break;
                if (i < len) continue;
 
 
 
                if (tmpS[0] == '-')
                {
                    minusFlag = 1;
                    for (i = 0; i < len - 1; i++)
                    { // אין נאל מסיים
                        tmpS[i] = tmpS[i + 1];
                    }
                    len--;
                }
                if (tmpS[0] == '0' && len > 1) continue; // אם כי יתכן שלא כולם יסכימו שמספר שמתחיל באפס לא חוקי
 
                if (len == 10)
                { // 2147483647 :זה המספר הכי גדול שמותר
                    if (tmpS[0] > '2') continue;
                    if (tmpS[0] == '2' && tmpS[1] > '1') continue;
                    if (tmpS[0] == '2' && tmpS[1] == '1' && tmpS[2] >= '4') continue;
                    // מספיק הפירוט הזה. אין באמת טעם לפרט הכל
                }
 
                // המרה ממערך צ'אר אל מספר
                number = 0;
                for (i = 1; len > 0; i *= 10, len--)
                { number += (tmpS[len - 1] - '0') * i; }
                if (minusFlag == 1) number *= -1;
 
 
 
 
                // בדיקת מינימום ומקסימום אם קיבלנו
                if (max != -99999)
                    if (number > max) continue; ;
                if (min != 99999)
                    if (number < min) continue; ;
 
 
                break;
            } while (true);
 
            return number;
        }
 
 
        public static void Get_Save_int_Numbers_From_User(String str, int min, int max, int[] List)
        {
            //
            // פונקציה מעולה לטיפול בבעיות הקטנות שבקליטת מספרים לא חוקיים מהמשתמש
            //  int אפשר להעתיק את הפונקציה הזו ולעשות בה שימוש בהרבה מאוד תוכניות לקליטה בטוחה של מספר
            //  הפונקציה הזו יחודית בכך שהיא עובדת עבור קלט של הרבה מספרים באותה שורה
            //
 
 
            int i, CountOfDigits;
            string tmpS;
            bool ProblemFlag;
 
 
            do
            {
                Console.WriteLine(str);
                tmpS = Console.ReadLine();
 
                // סריקה שבכל המחרוזת יש רק ספרות או מינוסים או רווחים או טאבים. גם בודק שהיא לא ריקה ממספרים
                for (i = 0, CountOfDigits = 0; i < tmpS.Length; i++)
                {
                    if (IsDigit(tmpS[i]) == false && IsSpaceOrTab(tmpS[i]) == false && tmpS[i] != '-') break;
                    if (IsDigit(tmpS[i]) == true) CountOfDigits++; // סופר כמה ספרות יש בסך הכל
                }
                if (i < tmpS.Length) continue;
                if (CountOfDigits == 0) continue;
 
 
 
 
 
                //  בדיקה שאין מינוס בסוף, שאין מינוס שאחריו אין סיפרה ושאין מינוס שלפניו אין תו לבן
                if (tmpS[tmpS.Length - 1] == '-') continue; // בדיקת המקום האחרון
                if (tmpS[0] == '-' && IsDigit(tmpS[1]) == false) continue; // בדיקת המקום הראשון. בבדיקה זו לא שייך לבדוק מה לפני התו הראשון
 
                ProblemFlag = false;
                for (i = 1; i < tmpS.Length - 1; i++) // מתחילים מהמקום השני. עד המקום אחד לפני האחרון
                {
                    if (tmpS[i] == '-')
                    {
                        if (IsSpaceOrTab(tmpS[i - 1]) == false) { ProblemFlag = true; break; } // נוודא שלפני מינוס יש תו לבן
                        if (IsDigit(tmpS[i + 1]) == false) { ProblemFlag = true; break; } // נוודא שאחרי מינוס יש סיפרה
                    }
                }
                if (ProblemFlag == true) continue;
 
 
 
 
 
 
 
 
 
                // "ArrayOfStringNumbers" הקטע הבא מזהה איפה נגמר כל מספר ומעתיק את המספרים למערך המספרים
                // הקטע גם בודק שאין יותר מדי או פחות מדי מספרים
                if (IsSpaceOrTab(tmpS[tmpS.Length - 1]) == true) continue; //(בודק שאין תו לבן בסוף (זה מקל את הבדיקה הבאה
 
                string[] ArrayOfStringNumbers = new string[List.Length];
                for (i = 0; i < tmpS.Length; i++)
                {
                    if (IsSpaceOrTab(tmpS[i]) == true) continue;
                    else break;
                }
                // הוא אינדקס המקום הראשון שיש בו סיפרה או מינוס i עכשיו 
 
                int IndexNumberInArray = 0;
                ProblemFlag = false;
                while (i < tmpS.Length)
                {
                    if (IsDigit(tmpS[i]) == true || tmpS[i] == '-')
                    {
                        ArrayOfStringNumbers[IndexNumberInArray] += tmpS[i];
                    }
                    else
                    { // אם זה תו לבן
                        // במידת הצורך IndexNumberInArray נעלה את 
                        if (IsDigit(tmpS[i - 1]) == true)
                        {
                            // (לא צריך לחשוש שהיינו על התו הראשון ותהיה חריגה אחורה, משום שכבר ידוע ש"איי" מצביע בהתחלה על המספר הראשון)
                            IndexNumberInArray++;
                        }
 
                        // נבדוק חריגה של יותר מספרים מהנחוץ
                        if (IndexNumberInArray == ArrayOfStringNumbers.Length)
                        {
                            ProblemFlag = true;
                            break;
                        }
                    }
                    i++;
                }
                if (ProblemFlag == true) continue;
                // :נבדוק בעיה של פחות מספרים מהנחוץ
                if (IndexNumberInArray < ArrayOfStringNumbers.Length - 1) continue;
 
 
 
 
 
 
 
 
 
                // נבדוק שאף מספר לא מכיל יותר מ-10 ספרות. וננתח אותן מעט
                for (i = 0; i < ArrayOfStringNumbers.Length; i++)
                {
                    if (ArrayOfStringNumbers[i].Length > 10) break;
                    if (ArrayOfStringNumbers[i].Length == 10)
                    { // 2147483647 :זה המספר הכי גדול שמותר
                        if (ArrayOfStringNumbers[i][0] > '2') break;
                        if (ArrayOfStringNumbers[i][0] == '2' && ArrayOfStringNumbers[i][1] > '1') break;
                        if (ArrayOfStringNumbers[i][0] == '2' && ArrayOfStringNumbers[i][1] == '1' &&
                            ArrayOfStringNumbers[i][2] >= '4') break;
                        // מספיק הפירוט הזה. אין באמת טעם לפרט הכל
                    }
                }
                if (i < ArrayOfStringNumbers.Length) continue;
 
 
 
 
 
 
 
 
                //  ונשמור במערך היעד ונבדוק מינימום ומקסימום int עכשיו נמיר כל מילה ל
                for (i = 0; i < ArrayOfStringNumbers.Length; i++)
                {
                    int x;
                    x = int.Parse(ArrayOfStringNumbers[i]);
                    if (x < min || x > max) break;
                    List[i] = x;
                }
                if (i < ArrayOfStringNumbers.Length) continue;
 
 
 
                break;
            } while (true);
        }
 
    }

אחרי שהוספתם אותה תוכלו לעשות שימוש בפונקציות שהיא מכילה.

דוגמה 1 - קליטת מספר אחד מהמשתמש:

    class Program
    {
        static void Main(string[] args)
        {
            int x;
            x = UsefulTools.Get_Save_int_Number_From_User("Enter number:");
            Console.WriteLine(x);
        }
    }

דוגמה 2 - קליטת מספר אחד מהמשתמש עם ערכי מינימום ומקסימום:

    class Program
    {
        static void Main(string[] args)
        {
            int x;
            x = UsefulTools.Get_Save_int_Number_From_User("Enter number (1-10):", 1, 10);
            Console.WriteLine(x);
        }
    }

דוגמה 3 - קליטת הרבה מספרים מהמשתמש (תמיד עם ערכי מינימום ומקסימום):
אגב: כאן עושים שימוש בפונקציה Get_Save_int_Numbers_From_User. פונקציה זו מקבלת מערך ומכניסה אליו את הערכים מהמשתמש, לפי אורך המערך.

[ולמה האריכות של שימוש במערך, במקום שימוש ב-ref ?
זאת משום שרצינו שהפונקציה תוכל לקבל כל כמות של משתנים מהמשתמש ולהשפיע עליהם.
בהתחשב בכך שבשפת #C אין מצביעים - בלי מערך היינו צריכים לקבל בפונקציה את הפרמטר: params ref int[] List
אבל שילוב של params ו-ref לא חוקי ב-#C! (בניגוד ל-C). ]

    class Program
    {
        static void Main(string[] args)
        {
            int[] Array = new int[4];
            UsefulTools.Get_Save_int_Numbers_From_User("Enter 4 numbers (1-10):", 1, 10, Array);
 
            for (int i = 0; i < Array.Length; i++)
            {
                Console.WriteLine(Array[i]);
            }
        }
    }

עריכה:
ב #C קיימת הפונקציה המובנת "()Int32.TryParse" שעושה את רוב מה שעשינו בכוחות עצמה.

שימוש:

    class Program
    {
        public static int GetSaveINT(String str)
        {
            int number;
            Console.Write(str);
            while (!Int32.TryParse(Console.ReadLine(), out number))
            {
                Console.Write(str);
            }
            return number;
        }
        static void Main()
        {
            int number = GetSaveINT("Enter number: ");
            Console.WriteLine("Your number is: " + number);
        }
    }

תיהנו!