היזהר בהשוואת מספרים ב-C++

C++ היא שפת תכנות בשימוש נרחב, אך גם כזו שבה שגיאות תכנות נפוצות ביותר. הרבה מהטעויות הללו נובעות משגיאות לוגיות. בפרט, שגיאות שנעשו במהלך פעולות השוואה יכולות להשפיע על הדיוק והאמינות של הקוד שלך.

לשפת C++ יש שגיאת השוואה מסוימת שמפתחים חדשים רבים מתעלמים ממנה. שגיאה זו נובעת מהבנה לא נכונה של אופן הפעולה של אופרטורים בעת ביצוע השוואות מרובות. גלה כיצד להימנע מהטעות הנפוצה הזו ומדוע היא מתרחשת מלכתחילה.

השוואות ב-C++

שפת התכנות C++ מציעה תכונות וכלים רבים ושונים, יחד עם פעולות בסיסיות כמו אופרטורים להשוואה. אופרטורי השוואה הם פעולות מיוחדות בשפות תכנות שבהן אתה יכול להשתמש כדי להשוות נתונים זה עם זה. מפתחים משתמשים באופרטורים אלה לעתים קרובות למדי, במיוחד בעת יצירת אלגוריתמים.

אתה יכול לראות מפעילי השוואה בדוגמאות רבות ושונות בחיי היומיום. לדוגמה, כאשר אתה קונה במכולת, אתה משתמש במפעילים אלה בחשבון כדי להשוות מחירים. אם המחיר של מוצר אחד נמוך מהאחר, אתה בוחר במוצר זה.

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

לדוגמה, בשפת התכנות C++, "==" המפעיל בודק אם שני ערכים שווים. אם הערכים שווים, התוצאה מחזירה אמת. אחרת, התוצאה תהיה שקרית.

אם (א == ב)
{
לַחֲזוֹרנָכוֹן;
} 
אַחֵר
{
לַחֲזוֹרשֶׁקֶר;
}

דוגמה לבעיית השוואה

אחת הטעויות הנפוצות למתחילים ב-C++ היא השימוש באופרטורים להשוואה. אופרטורים אלו מאפשרים למתכנתים להשוות בין שני ערכים ולבצע פעולות שונות על סמך התוצאה של השוואה זו. עם זאת, שימוש שגוי באופרטורים אלה עלול לגרום לשגיאות בלתי צפויות.

לדוגמה, למרות שהביטוי 3 < 15 < 10 אינו נכון מבחינה מתמטית, C++ מחשיב את התוצאה שלו כנכונה. אתה יכול להדגים זאת על ידי כתיבת תוכנית המבחן הפשוטה הבאה.

ראשית, צור קובץ בשם test.cpp. פתח את הקובץ הזה באמצעות שלך עורך קוד מועדף והוסיפו לו את הקוד הבא.

#לִכלוֹל
int א = 15;
intרָאשִׁי()
{
אם (3 < א < 10)
 {
סטד::cout << "פו" << סטד::endl;
 }
אַחֵר
 {
סטד::cout << "בו" << סטד::endl;
 }
לַחֲזוֹר0;
}

אתה יכול להשתמש בפקודה זו כדי לקמפל ולהפעיל את הקוד:

g++ test.cpp -o Test

כעת יש לך תוכנית בשם מִבְחָן. הפעל את התוכנית ובחן את הפלט שלה.

C++ נחשב 3 < 15 < 10 להיות נכון בעת ​​הפעלת תוכנית זו. מדוע עשויה התוצאה לצאת כך, למרות שזו אמירה לא נכונה מבחינה מתמטית?

הסיבות לבעיית ההשוואה ב-C++

כמו רוב שפות התכנות, C++ קורא קוד משמאל לימין. כל אופרטור השוואה מייצר ערך בוליאני. ערכים בוליאניים אינם משמעם רק אמת ושקר; יש להם מקבילה מתמטית.

עקרון העבודה של א המחשב תלוי באחדים ובאפסים. עבור מחשב, התוצאה של משהו היא אמיתית או שקרית. תוכנות מחשב מתייחסות בדרך כלל למספר 1 כאמת ולמספר 0 כאל לא נכון.

בחן שוב את בעיית ההשוואה וקרא את ההצהרה משמאל לימין; תראה שיש שתי השוואות שונות. ההשוואה הראשונה היא בין המספרים 3 ל-15. זהו ערך אמיתי מכיוון ש-3 הוא פחות מ-15.

ההשוואה השנייה היא בין התוצאה הזו לבין המספר 10. מכיוון שהוא צריך לבצע השוואה מספרית, C++ ממיר בשקט את הערך האמיתי הבוליאני ל-1. 1 הוא פחות מ-10, כך שהתוצאה הכוללת נכונה.

לסיכום, למרות שזה נראה כמו כשל מתמטי, הצהרה זו נכונה עבור C++ ומחשבים.

כיצד לפתור בעיות השוואה ב-C++

C++, יחד עם רוב שפות התכנות האחרות, משתמש בתחביר שונה להשוואה לוגית מאשר במתמטיקה מסורתית. הביטוי המתמטי 3 < a < 15 פירושו "3 הוא פחות מ-a ו a פחות מ-15." עם זאת, כפי שראית, C++ מפרש את הביטוי הזה אחרת.

כדי לייצג וב-C++, השתמש באופרטור &&. לאחר מכן תוכל לשרשר ביטויים בוליאניים ולבנות היגיון באמצעות אופרטורים כמו && לייצג ו, || לייצג OR, ו ! לייצג את NOT. שפות כמו Java משתמש באופרטורים לוגיים.

באמצעות האופרטור הלוגי הנכון, תוכל לתקן את הבאג בדוגמה הקודמת:

#לִכלוֹל
int א = 15;
intרָאשִׁי()
{
אם (3 < a && a < 10)
 {
סטד::cout << "פו" << סטד::endl;
 }
אַחֵר
 {
סטד::cout << "בו" << סטד::endl;
 }
לַחֲזוֹר0;
}

כעת הקוד הזה יבדוק אם הערך a גדול מ-3 והאם הערך a קטן מ-10. קומפלו והריצו את התוכנית והתבוננו בתוצאה.

הדוגמה הקודמת הדפיסה "פו", אך התוכנית מדפיסה כעת "בו", כמתוכנן. הערך הבוליאני של הצד השמאלי של ההשוואה (3 < a) נכון. הערך של הצד הימני (a < 10) הוא שקר. מאז נכון ולא נכון תמיד שֶׁקֶר, הביטוי הכולל מוערך ל-false, כך שהתנאי נכשל וה- אַחֵר ריצות בלוק.

נסה להחליף את ה-AND (&&) אופרטור ל-OR (||) והתבוננות בתוצאה השונה.

החשיבות של בדיקות לוגיות ב-C++

השוואות לוגיות ב-C++ כוללות שימוש בערכים בוליאניים ואופרטורים להשוואה. ודא שאתה משתמש בערכים הבוליאניים ובאופרטורי ההשוואה הנכונים כדי לשלוט בפעולת התוכניות שלך. זה יכול להיות קשה לזהות ביטויים בעלי צורה גרועה מכיוון ש-C++ לרוב יבצע התנהגות שונה במקום להיכשל לחלוטין.

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