דוגמה 1:
כעת, הבה נבצע כמה דוגמאות שבהן אנו משתמשים ב'סוג נתונים בוליאני' זה ונראה שהוא עובד ב-C++. אנו מתחילים את הקוד שלנו על ידי הוספת קבצי הכותרות שאנו דורשים. קובץ הכותרת הראשון שאנו מוסיפים כאן הוא '
לאחר מכן, יש לנו קוד מנהל התקן שמשמעותו שאנו מוסיפים כאן את הפונקציה 'main()'. כעת, אנו מכריזים על המשתנה 'isBulbOn' עם סוג הנתונים הבוליאני 'bool' ומכוונים כאן 'true'. מתחת לזה, יש לנו משתנה בוליאני נוסף בשם 'isBulbOff' בו נוסיף 'false'. התוצאה האמיתית והשגויה הזו הן '1' ו- '0', בהתאמה.
כדי לבדוק את הפלט של ערכים בוליאניים אלה, אנו פשוט מדפיסים אותם באמצעות המשפט 'cout'. בהצהרת 'cout' זו, אנו מדפיסים תחילה את תוצאת 'isBulbOn'. לאחר מכן, בשורה הבאה, אנו מדפיסים את התוצאה של המשתנה 'isBulbOff'. ה-'endl' משמש כאן כך שהוא מעביר את המצביע שלנו לשורה הבאה.
קוד 1:
#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
bool isBulbOn = נָכוֹן ;
bool isBulbOff = שֶׁקֶר ;
cout << 'הנורה דולקת כאן' << isBulbOn << endl ;
cout << 'הנורה לא דולקת כאן' << isBulbOff ;
}
תְפוּקָה:
הפלט של קוד זה מייצג את התוצאה בצורות '0' ו- '1' כפי שמוצג להלן. כאן, '1' מציין את התוצאה 'האמיתית' ואילו '0' מציין את התוצאה 'שגויה'. אנו משיגים תוצאה זו רק בגלל סוג הנתונים 'bool'.
דוגמה 2:
כעת, אנו מכריזים על שני משתנים, 'עובר' ו'נכשל', של סוג הנתונים 'בול' בתוך ה-main לאחר הכללת קובץ הכותרת בתחילת הקוד הזה. המשתנה 'עובר' מוקצה כ'נכון' כאן, והמשתנה 'נכשל' מוקצה כ'לא נכון'. כעת, 'עובר' מחזיר '1' כתוצאה מכך ו'נכשל' מחזיר '0'.
כעת, אנו משתמשים במשתני bool אלה בהצהרת 'cout' שלנו כדי לקבל את התוצאה האמיתית או הלא נכונה בצורה של '1' ו- '0'. ה-'cout' שבו שמנו את 'Pass' מחזירה '1'. כאשר אנו משתמשים ב-'Fail' מחזירה '0'. כאן, אנו מוסיפים חמש הצהרות 'cout', שכל אחת מהן מכילה את המשתנה הבוליאני.
קוד 2:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
bool Pass = נָכוֹן ;
bool נכשל = שֶׁקֶר ;
cout << 'האחוז הוא 60' << לַעֲבוֹר << endl ;
cout << 'האחוז הוא 45' << לְהִכָּשֵׁל << endl ;
cout << 'האחוז הוא 90' << לַעֲבוֹר << endl ;
cout << 'האחוז הוא 85' << לַעֲבוֹר << endl ;
cout << 'האחוז הוא 33' << לְהִכָּשֵׁל << endl ;
}
תְפוּקָה:
בפלט זה, '1' מייצג את התוצאה 'האמיתית' שהיא 'עובר' ו- '0' מייצג את התוצאה 'שגויה' שהיא 'נכשל' במקרה זה.
דוגמה 3:
בקוד זה, אנו מאתחלים שלושה משתנים שלמים שהם 'num_01', 'num_02' ו-'a' עם הערך של '45', '62' ו-'3', בהתאמה. לאחר מכן, אנו מכריזים על שלושה משתנים נוספים - 'b_01', 'b_02', ו-'b_03' - ואלה הם סוג הנתונים הבולאני 'bool'. כעת, אנו מאתחלים את 'b_01' עם התנאי 'num_01 == num_01'. לאחר מכן, אנו מאתחלים את 'b_02' ו-'b_03' באותם דרכים כמו 'b_01'.
לאחר אתחול כל המשתנים, אנו מדפיסים אותם בנפרד באמצעות 'cout' כדי לבדוק את התוצאה של משתנים בוליאניים אלה. לאחר מכן, אנו מאתחלים את המשתנה 'b_a' של סוג הנתונים 'bool' עם 'true'. לאחר מכן, אנו משתמשים בהצהרת 'אם' כאן במקום שבו אנו מציבים את 'b_a' כתנאי. כעת, אם תנאי 'b_a' זה נכון, ההצהרה לאחר 'if' מבוצעת. אחרת, החלק 'אחר' יתבצע כאן. לאחר מכן, אנו ממשיכים ומאתחלים את משתנה המספר השלם 'num' בו אנו מיישמים כמה פעולות מתמטיות ומציגים את התוצאה 'num'.
קוד 3:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int num_01 = ארבע חמש , num_02 = 62 , א = 3 ;
bool b_01 , b_02 , b_03 ;
b_01 = num_01 == num_01 ;
b_02 = num_01 == num_02 ;
b_03 = num_02 > num_01 ;
cout << 'התשובה של Bool b_01 הראשון היא = ' <<
b_01 << endl ;
cout << 'התשובה של Bool השני b_02 היא = ' <<
b_02 << endl ;
cout << 'התשובה של Bool שלישית b_03 היא = ' <<
b_03 << endl ;
bool b_a = נָכוֹן ;
אם ( תוֹאַר רִאשׁוֹן )
cout << 'כן' << endl ;
אַחֵר
cout << 'לא' << endl ;
int על אחד = שֶׁקֶר + 7 * א - תוֹאַר רִאשׁוֹן + נָכוֹן ;
cout << על אחד ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מציגה את התוצאות של הפעולות שביצענו בקוד שלנו. אז, בדרך זו, אנו משתמשים ב'סוג נתונים בוליאני' בקודי C++ שלנו.
דוגמה 4:
כאן, אנו מקלידים 'isHotDay' כמשתנה 'bool' ומאתחלים אותו עם 'false'. כעת, אנו משתמשים בהצהרת 'if' ומעבירים את 'isHotDay' כתנאי. ההצהרה שאחרי 'if' מבוצעת כעת אם מתקיים תנאי 'isHotDay'. אחרת, החלק 'אחר' יפעל בשלב זה.
כעת, יש לנו את המשתנה הבולאני 'DoTask' והגדרנו אותו ל'true'. יתר על כן, אנו גם מאתחלים את המשתנה 'int' בשם 'Task_count'. לאחר מכן, אנו מניחים את הלולאה 'while()'. בלולאת 'while()' הזו, שמנו את 'DoTask' כתנאי. בתוך לולאת ה-while, אנו כותבים 'Task_count++' אשר מגדיל את הערך של 'Task_count' ב-1.
כאשר הצהרה זו מבוצעת, הערך של 'Task_count' גדל ב-1. לאחר מכן, המשפט 'cout' הבא מבוצע. לאחר מכן, אנו מציבים שוב תנאי שהוא 'Task_count < 9' ומקצים תנאי זה למשתנה 'DoTask'. לולאה זו פועלת עד ש-'Task_count' קטן מ-'9'.
קוד 4:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
bool isHotDay = שֶׁקֶר ;
אם ( הוא יום חם ) {
cout << 'זה יום חם!' << endl ;
} אַחֵר {
cout << 'זה לא יום חם' << endl ;
}
bool DoTask = נָכוֹן ;
int ספירת_משימה = 0 ;
בזמן ( DoTask ) {
ספירת_משימה ++;
cout << 'המשימה היא המשך כאן' << ספירת_משימה << endl ;
DoTask = ( ספירת_משימה < 9 ) ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
פלט זה מציג את התוצאה של כל פעולה שהרצנו בקוד שלנו. לפיכך, אנו משתמשים גם ב'סוג נתונים בוליאני' בקודי C++ שלנו באופן זה.
דוגמה 5:
כעת, אנו מתקדמים לעבר הדוגמה האחרונה של הדרכה זו. כאן, אנו לוקחים שלושה משתנים בוליאניים ייחודיים ומדפיסים את שניהם. לאחר מכן, אנו מיישמים את האופרטורים 'AND', 'OR' ו-'NOT' על המשתנים הבוליאניים הללו. כמו כן, התוצאה של כל הפעולות נשמרת בצורה בוליאנית מכיוון שהוספנו 'bool' עם כל המשתנים שבהם מאוחסנת התוצאה של פעולות אלו. לאחר מכן, אנו מדפיסים את התוצאות של פעולות אלו שוב בבוליאנית.
קוד 5:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
bool value_1 = נָכוֹן ;
bool value_2 = שֶׁקֶר ;
bool value_3 = נָכוֹן ;
cout << 'ערך_1 הוא ' << value_1 << endl ;
cout << 'ערך_2 הוא ' << ערך_2 << endl ;
cout << 'ערך_3 הוא ' << value_3 << endl << endl ;
bool outcome_1 = ( value_1 || value_3 ) && value_1 ;
bool outcome_2 = value_1 && ערך_2 ;
bool outcome_3 = ערך_2 || value_3 ;
bool outcome_4 = ! value_3 ;
bool outcome_5 = ! ערך_2 ;
bool outcome_6 = ! value_1 ;
cout << 'התוצאה 1 היא = ' << תוצאה_1 << endl ;
cout << 'התוצאה 2 היא = ' << תוצאה_2 << endl ;
cout << 'התוצאה 3 היא = ' << תוצאה_3 << endl ;
cout << 'התוצאה 4 היא = ' << תוצאה_4 << endl ;
cout << 'התוצאה 5 היא = ' << תוצאה_5 << endl ;
cout << 'התוצאה 6 היא = ' << תוצאה_6 << endl ;
}
תְפוּקָה:
הנה התוצאה. אנו עשויים לשים לב שהתוצאה של כל פעולה מוצגת בצורה של '0' ו- '1' כי נעשה שימוש בסוג הנתונים 'bool'.
סיכום
במדריך זה, הדגמנו כיצד משתמשים בסוג הנתונים הבוליאניים ב-C++ ומהי התוצאה של סוג הנתונים הבוליאניים. בדקנו את הדוגמאות שבהן השתמשנו בסוג נתונים בוליאני זה. ראינו שסוג הנתונים הבוליאניים הזה יעיל ופשוט, אבל חיוני לנצל אותו בזהירות כדי למנוע טעויות.