דוגמה 1:
הקוד מתחיל כאן על ידי הכללת קובץ הכותרת 'iostream'. כפי שהשם מרמז, קובץ כותרת זה מיועד לפונקציות הקלט והפלט, שכן הפונקציות הללו מוצהרות בו. לאחר מכן, יש לנו את 'מרחב השמות std' שבו הפונקציות הללו מוגדרות.
מתחת לזה, אנו קוראים לשיטת 'main()'. אנו מאתחלים את המשתנה 'x' מהסוג 'int' ומקצים '10' ל-'x זה'. לאחר מכן, יש לנו משתנה נוסף, 'y', מסוג הנתונים 'int' ונקצה '6'. לאחר מכן, אנו מאתחלים את 'r' מסוג הנתונים 'int'. כאן, אנו מיישמים את פעולת 'XOR' על הערכים של משתני 'x' ו-'y על ידי מיקום האופרטור '^' בין משתנים אלה. אופרטור 'XOR' זה ממיר את ערכי המספרים השלמים לבינארי, מיישם את פעולת 'XOR' על הערכים הבינאריים ושומר את התוצאה כערך המספרים השלם. התוצאה של אופרטור 'XOR' זה נשמרת כעת ב-'r'.
לאחר מכן, אנו מציגים את הערכים של משתנים אלו בנפרד ולאחר מכן מציגים את התוצאה שאנו מקבלים לאחר החלת האופרטור 'XOR' בעזרת 'cout'.
קוד 1:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int איקס = 10 ;
int ו = 6 ;
int ר = איקס ^ ו ;
cout << 'הערך של x :' << איקס << endl ;
cout << 'הערך של y:' << ו << endl ;
cout << 'XOR x ^ y = ' << ר << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
מכיוון שהערך הבינארי של '10' הוא '1010' והערך הבינארי של '6' הוא '0110', הוא מחזיר '12' לאחר החלת האופרטור 'XOR' ו-'1100' הוא הערך הבינארי של '12'. זה מראה שהוא מחזיר '1' כאשר שתי הכניסות שונות ומחזיר '0' כאשר שתי הכניסות זהות.
דוגמה 2:
לאחר הוספת קובץ הכותרת 'iostream' ומרחב השמות 'std', אנו מפעילים את שיטת 'main()'. לאחר מכן, אנו מאתחלים שני משתנים, 'X1' ו-'X2', ומקצים את ערכי המספרים השלמים '21' ו- '35' למשתנים אלה, בהתאמה. לאחר מכן, אנו מדפיסים את ערכי שני המשתנים. לאחר מכן, אנו מיישמים את האופרטור 'XOR' על ערכי המספרים השלמים הללו. אנו מיישמים את פעולת 'XOR' זו על משתני 'X1' ו-'X2' אלה בתוך ה-'cout'. אז, התוצאה של 'XOR' זה מוצגת גם כתוצאה.
קוד 2:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int X1 = עשרים ואחת , X2 = 35 ;
cout << 'ערך X1 = ' << X1 << endl ;
cout << 'ערך X2 = ' << X2 << endl ;
cout << 'תוצאת XOR היא:' << endl ;
cout << 'X1^X2 = ' << ( X1 ^ X2 ) << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הערך השלם הראשון הוא '21' והשני הוא '35'. לאחר החלת פעולת 'XOR', נקבל את תוצאת '54' המוצגת כאן.
דוגמה 3:
אנו קוראים לשיטת 'main()' לאחר הוספת קובץ הכותרת 'iostream' ומרחב השמות 'std'. המשתנה 'n1' מהסוג 'int' מאותחל ומוקצה לו '29'. לאחר מכן, אנו מקצים '75' למשתנה אחר, 'n2', שהוא מסוג הנתונים 'int'. לאחר מכן, אנו מאתחלים את הערך של 'r1' כמו גם את זה של סוג הנתונים 'int'.
לאחר מכן, אנו מיישמים את פעולת 'XOR' על הערכים של המשתנים 'n1' ו- 'n2' על ידי מיקום האופרטור '^' ביניהם. ערכי המספרים השלמים מומרים לבינאריים באמצעות אופרטור 'XOR' זה אשר לאחר מכן מחיל את פעולת 'XOR' על הנתונים הבינאריים ושומר את התוצאה כערך מספר שלם. המשתנה 'r1' מכיל כעת את התוצאה של פעולת 'XOR' זו. הערכים של כל אחד מהמשתנים הללו מוצגים בנפרד. אנו גם מציגים את התוצאה של שימוש באופרטור 'XOR' בסיוע מפעיל 'cout'.
קוד 3:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int n1 = 29 ;
int n2 = 75 ;
int r1 = n1 ^ n2 ;
cout << 'הערך הראשון:' << n1 << endl ;
cout << 'הערך השני:' << n2 << endl ;
cout << 'התוצאה של מפעיל XOR היא:' << r1 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
מספרי הקלט השלמים הם '29' ו-'75' המומרים לבינאריים. לאחר מכן, פעולת 'XOR' מוחלת עליהם. לאחר החלת 'XOR', התוצאה היא '86'.
דוגמה 4:
בקוד זה, אנו מקבלים את הקלט מהמשתמש ולאחר מכן מיישמים את פעולת 'XOR' על ערכי הקלט של המשתמש. שלושת המשתנים מוצהרים כאן בשמות 'Xvalue1', 'Xvalue2' ו-'Xvalue3'. לאחר מכן, אנו מניחים את ה-'cout' ומציגים את ההודעה 'הזן שני ערכים כאן'.
לאחר הצגת הודעה זו, המשתמש מזין את הערכים שאנו מקבלים בעזרת ה-cin. אז, אנו מניחים 'cin' מתחת לזה. שני הערכים מאוחסנים כעת במשתנים אלה ומוצגים גם כאן. כעת, עלינו להחיל את פעולת 'XOR', אז נכניס את האופרטור '^' בין המשתנים 'Xvalue1' ו-'Xvalue2'.
כעת, פעולת 'XOR' זו מוחלת על הערכים של משתנים אלה. לאחר מכן, התוצאה של אופרטור 'XOR' זה נשמרת במשתנה 'Xvalue3'. אנו מציגים אותו גם בשיטת 'cout'.
קוד 4:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int Xvalue1 , Xvalue2 , Xvalue3 ;
cout << 'הזן ערכים שני ערכים כאן: ' << endl ;
cout << 'Xvalue1: ' ;
אֲכִילָה >> Xvalue1 ;
cout << 'Xvalue2: ' ;
אֲכִילָה >> Xvalue2 ;
Xvalue3 = Xvalue1 ^ Xvalue2 ;
cout << ' \n כעת, לאחר החלת XOR על שני הערכים: ' << endl ;
cout << 'Xvalue1 ^ Xvalue2 = ' << Xvalue3 << endl ;
}
תְפוּקָה:
כאשר אנו מבצעים את הקוד הזה, הוא מדפיס הודעה להזנת שני ערכים. לכן, נזין '14' בתור הערך של המשתנה 'Xvalue1' ו-'45' בתור הערך של המשתנה 'Xvalue2'. לאחר מכן, נלחץ על 'Enter'. לאחר מכן, פעולת 'XOR' מוחלת על ערכים אלה, אשר ממירה את שני הערכים לבינאריים ולאחר מכן מציגה את התוצאה כאן.
דוגמה 5:
אנו מיישמים את פעולת 'XOR' זו על נתוני התווים. אנו מאתחלים שני משתני 'char' עם השמות 'ch_a' ו-'ch_b'. אנו מקצים 'a' ו- '8' למשתנים אלה, בהתאמה. לאחר מכן, אנו ממקמים את האופרטור '^' בין 'ch_a' ו-'ch_b' ומקצים אותו למשתנה 'ch_result' שהוא גם סוג הנתונים 'char'. תווים אלה מומרים לבינאריים, והתוצאה נשמרת במשתנה 'ch_result'. לאחר מכן נדפיס את שני המשתנים ואת התוצאה של פעולת 'XOR' זו.
קוד 5:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
לְהַשְׁחִיר ch_a = 'א' ;
לְהַשְׁחִיר ch_b = '8' ;
לְהַשְׁחִיר ch_result = ch_a ^ ch_b ;
cout << 'הדמות הראשונה היא:' << ch_a << endl ;
cout << 'הדמות השנייה היא:' << ch_b << endl ;
cout << 'התוצאה היא : ' << ch_result << endl ;
}
תְפוּקָה:
תווי הקלט הם 'a' ו-'8' והתוצאה של 'XOR' מוצגת כ-'Y' שאנו מקבלים לאחר החלת פעולת 'XOR' הממירה 'a' ו- '8' לבינארי ולאחר מכן מבצעת את ' פעולת XOR'.
סיכום
פעולת 'XOR' נחקרת כאן ביסודיות והסברנו שזוהי הפעולה 'ביזית' מכיוון שהיא משתמשת בערכים הבינאריים. דנו בכך שכל הערכים שהזנו כדי להחיל את פעולת 'XOR' מומרים לערכים בינאריים, ולאחר מכן מבוצעת פעולת 'XOR'. הדגמנו מספר דוגמאות והראנו כיצד פעולת 'XOR' פועלת בתכנות C++.