דוגמה 1:
בואו נעבור על תוכנית C# המדגימה את השימוש באופרטור XOR (^) כדי לקבוע את בריאותו של מזון על סמך האם הוא צמחוני או מכיל בשר. השורה הראשונה 'באמצעות מערכת;' היא הצהרת מרחב שמות המאפשרת לתוכנית לגשת למחלקות ולפונקציות המוגדרות במרחב השמות 'מערכת' המכיל את הסוגים הבסיסיים ופונקציונליות הליבה של C#. הקוד מגדיר מחלקה ציבורית בשם 'דמה'.
מילת המפתח הציבורית מציינת שניתן להיכנס לכיתה מחלקים אחרים של התוכנית. בתוך המחלקה 'Dummy', יש שיטה סטטית בשם 'Main'. שיטת 'Main' לוקחת מערך של מחרוזות (string[] args) כפרמטר המאפשר העברת ארגומנטים של שורת הפקודה לתוכנית.
בתוך שיטת ה-'Main', מכריזים ואותחלים שלושה משתנים בוליאניים: 'isVeg' מוגדר כ-true המציין אם האוכל הוא צמחוני, 'isMeat' מוגדר כ-false המציין אם האוכל מכיל בשר, 'IsFit' מוצהר ומוקצה עם התוצאה של פעולת XOR (isVeg ^ isMeat) הקובעת את בריאות המזון על סמך מצבו הצמחוני ותכולת הבשר.
השורה Console.WriteLine מוציאה את התוצאה של בדיקת הבריאות באמצעות אינטרפולציית מחרוזת. הערך של 'isFit' מוצג בתוך המחרוזת שמציינת אם האוכל נחשב בריא או לא.
באמצעות System ;
דמה בכיתה ציבורית {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
bool isVeg = נָכוֹן ;
bool isMeat = שֶׁקֶר ;
bool isFit = isVeg ^ isMeat ;
לְנַחֵם. WriteLine ( $ 'האם האוכל בריא? : {isFit}' ) ;
}
}
לסיכום, קוד זה מציג את הרעיון של לוגיקה בוליאנית ב-C# וכיצד ניתן להשתמש באופרטור XOR כדי לקבוע את ה-XOR הלוגי של שני משתנים בוליאניים ולהעריך את בריאותו של מזון בהתבסס על האם הוא צמחוני או מכסה בשר.
דוגמה 2:
בואו נדגים את השימוש באופרטור XOR ב-C# באמצעות דוגמה נוספת של קוד. נבצע פעולת XOR בצורה סיבית על שני משתנים שלמים (n1 ו-n2). הקוד מתחיל ב'שימוש במערכת;' הצהרה המייבאת את מרחב השמות 'System' כדי לאפשר שימוש במחלקות המוגדרות במרחב השמות 'System' כגון המחלקה 'Console'.
הקוד מגדיר מחלקה בשם 'צ'ק' תוך שימוש בתחביר 'בדיקת מחלקה ציבורית'. מחלקה זו מכילה שיטה אחת שהיא 'Mai'. הפונקציה main() לוקחת את מערך המחרוזות 'args' כפרמטר שניתן להשתמש בו כדי להעביר את ערכי שורת הפקודה לתוכנית הקוד.
בתוך שיטת Main(), שני משתנים שלמים, 'n1' ו-'n2', מוכרזים ומאותחלים עם הערכים 17 ו-8, בהתאמה. לערך 'n1' יש ייצוג בינארי של 10001 כלומר הוא שווה לעשרוני 17, ולערך 'n2' יש ייצוג בינארי של 1000 כלומר הוא שווה ל-8 עשרוני.
ה-'int Res = n1 ^ n2;' line מחשבת את התוצאה של פעולת XOR בין 'n1' ל-'n2' באמצעות האופרטור XOR (^). התוצאה נשמרת ב-Res mutable. פעולת XOR מיושמת על הייצוגים הבינאריים של 'n1' ו- 'n2'. הוא משווה כל סיביות מתאימה של הייצוגים הבינאריים ומגדיר את הסיביות המתקבלות ל-1 אם הסיביות שונות ו-0 אם הסיביות זהות.
ביצוע פעולת ה-XOR, נקבל את התוצאה הבינארית של 11001 ששווה לעשרוני 25. The Console.WriteLine($”Result: {Res}”); קו מדפיס את התוצאה של פעולת XOR לקונסולה. השיטה Console.WriteLine משמשת להצגת המחרוזת 'Result:' ואחריה הערך של המשתנה 'Res'. התחביר {$'Result: {Res}'} נקרא אינטרפולציית מחרוזת המאפשרת לנו להטמיע את הערך של המשתנה 'Res' ישירות לתוך המחרוזת.
באמצעות System ;צ'ק בכיתה ציבורית {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
int n1 = 17 ; // 10001
int n2 = 8 ; // 1000
int מילון = n1 ^ n2 ;
לְנַחֵם. WriteLine ( $ 'תוצאה: {Res}' ) ;
}
}
מסך מסוף הפלט שמוצג בתמונה הבאה מציג את התוצאה '25' שמתקבלת על ידי שימוש בפעולת XOR בין 17 ל-8:
דוגמה 3:
בואו נעבור לדוגמא האחרונה של מאמר זה הקובעת את השימוש באופרטור XOR ב-C#. קטע הקוד המצורף הבא מתחיל ב'שימוש במערכת;' משפט שמייבא את מרחב השמות 'System'.
לאחר מכן, מעמד ציבורי בשם 'מבחן' מוכרז. מחלקה זו מבוטלת כנקודת ההתחלה כאן ומכסה גם את שיטת main() . בתוך שיטת 'Main()', אנו מבצעים את פעולת XOR על ערכי תווים. שני משתני 'char', 'L1' ו-'L2', מוצהרים ומוקצים עם ערכי 'M' ו-'R', בהתאמה.
משתנים אלו מייצגים את התווים. משתנה 'char' נוסף בשם 'Res' מוצהר ומוקצה עם התוצאה של פעולת XOR בין 'L1' ל-'L2'. פעולת XOR מבוצעת באמצעות אופרטור XOR '^'.
מכיוון שהאופרטור XOR עובד על ערכי מספר שלם, הקאסט (char) משמש להמרת הערך השלם המתקבל בחזרה לתו. ההצהרה של Console.WriteLine מבוטלת כדי להדפיס את התוצאה. הוא משתמש באינטרפולציה של מחרוזת (`$`) כדי לכלול את הערך של 'Res' בפלט.
כאשר התוכנית מבוצעת, שיטת main() נקראת והפלט הבא מוצג במסוף. במקרה זה, פעולת ה-XOR בין התווים 'M' ו-'R' גורמת ל-'?' או '.' אופי. התו המתקבל מודפס כחלק מהפלט.
באמצעות System ;מבחן בכיתה ציבורית {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
לְהַשְׁחִיר L1 = 'M' ;
לְהַשְׁחִיר L2 = 'ר' ;
לְהַשְׁחִיר מילון = ( לְהַשְׁחִיר ) ( L1 ^ L2 ) ;
לְנַחֵם. WriteLine ( $ 'תוצאה: {Res}' ) ;
}
}
זה הסבר מפורט של הקוד שסופק קודם לכן. זה מציג כי האופרטור XOR משמש לביצוע פעולת Bitwise XOR על ערכי תווים ולהדפיס את התוצאה כפי שמוצגת בתמונה המצורפת הבאה:
סיכום
האופרטור C# XOR מספק כלי גמיש לביצוע פעולות Bitwise והלוגיות. זה מאפשר לך לעבוד עם ביטים בינאריים ולבטא את התנאים הייחודיים בלוגיקה בוליאנית. באמצעות דוגמאות הקוד, דנו כיצד ניתן להחיל את האופרטור XOR על ערכים בוליאניים, ערכים שלמים וערכי תווים כדי לקבל את הפלט הרצוי. שימוש נכון באופרטור XOR, אתה יכול לשפר את כישוריך כמתכנת C#.