נושא הדיון שלנו הוא על מפעילי המשמרת. האופרטור של משמרת שמאל של Bitwise (<<) יוסבר בפירוט. האופרטור Shift, כפי שהשם מרמז, מעביר את הביט מהמיקום שצוין שמאלה או ימינה. הערך מועבר שמאלה במספר הסיביות שצוין תוך שימוש באופרטור ההזזה שמאלה (<<). אופרטורי המשמרת השמאלית לוקחים את הקלט רק ב-int (מספר שלם), uint (מספר שלם ללא סימן), ארוך (מספר שלם ארוך) ו-ulong (מספר שלם ארוך ללא סימן). כאשר האופרנד השמאלי שייך לסוג אחר, הוא מומר לסוג מספר שלם. סוג הנתונים של הערך המתקבל שומר על מגבלה של 32 סיביות; הפלט לא יכול להיות גדול מזה. מפעילי Bitwise הופכים את הקוד ליעיל ומהיר יותר. יתר על כן, הם מציעים יותר דיוק ודיוק.
תחביר:
Operand_1 << Operand_2
ה-'Operand_1' הראשון הוא הערך המוזז משמאל למספר ההזזות שה-'Operand_2' מכיל. הסמל << שמאלה מעביר את ה-'Operand_1'.
דוגמה 1:
האופרטור Bitwise left shift (<<) מוחל על ערכי המספרים השלמים בתוכנית זו.
שימוש במערכת;
תוכנית כיתה_1
{
ריק סטטי ראשי ( ) {
int Value_0 = 3. 4 ;
int Value_1 = 65 ;
int מילואים = Value_0 << ערך_1;
קונסולה.כתוב ( 'המעבר השמאלי הוא ' ) ;
קונסולה.כתוב ( מילואים ) ;
}
}
ההצהרה הראשונה מכילה הכרזה ואתחול של שני משתנים מסוג מספר שלם. המשתנה הראשון הוא 'Value_0' והמשתנה השני הוא 'Value_1'. הערכים המאוחסנים בהם הם '34' ו-'65'. השארנו את הערך 34 באמצעות אופרטור ההזזה השמאלי (<<). לאחר מכן, אנו מכריזים על משתנה נוסף שיש לו סוג נתונים שלמים כדי לשמור את התוצאה. כאן, אנו משתמשים באופרטור המשמרת השמאלית (<<) בתור Value_0 << Value_1. אופרטור זה שמאלה מעביר את הערך השמאלי של האופרנד השמאלי בערך הנתון באופרנד השני. ה'מיל' מאחסן את הפלט של מפעיל המשמרת. לאחר מכן, אנו קוראים לשיטת Console.Write() כדי להדפיס את הטקסט 'The left shift is' ואת הערך המתקבל המאוחסן ב-'res' בטרמינל.
דוגמה 2:
בואו נשתמש באופרטור המשמרת השמאלי על ערכי המספרים השלמים ללא סימן ונראה כיצד הם מייצרים את הפלט.
שימוש במערכת;
תוכנית כיתה_2
{
ריק סטטי ראשי ( ) {
uint Val_0 = 4435 ;
int Val_1 = 64 ;
uint תוֹצָאָה = Val_0 << Val_1;
קונסולה.כתוב ( 'המשמרת השמאלית היא' ) ;
קונסולה.כתוב ( תוֹצָאָה ) ;
}
}
כאן, אנו מיישמים את אופרטור המשמרת השמאלית על ערך סוג מספר שלם ללא סימן. דבר אחד שאתה חייב להקפיד עליו הוא שהאופרנד השני חייב להיות ערך מסוג שלם מכיוון שהמהדר לוקח רק ערך שלם כדי להזיז.
לאחר קריאה לפונקציה סטטית void Main() אנו מכריזים על שני משתנים - אחד מהם הוא ערך שלם ללא סימן 'Val_0' והשני הוא ערך שלם 'Val_1'. לאחר מכן, אנו מגדירים משתנה נוסף של מספר שלם ללא סימן שהוא 'תוצאה' כדי לשמור על הערך המתקבל לאחר הזזת המספר השלם ללא סימן שמאלה. איננו יכולים לאחסן את התוצאה במשתנה מסוג מספר שלם כי לאחר ההזזה שמאלה, התוצאה היא ערך ללא סימן. המשפט 'Val_0 << Val_1' שמאלה מעביר את האופרנד השמאלי שהוא ערך מספר שלם ללא סימן. הוא מייצר ערך מספר שלם ללא סימן. בסופו של דבר, הצג את התוצאה במסך הפלט עם הטקסט 'The left shift is' באמצעות שיטת Console.Write():
דוגמה 3:
במקרה זה, נדבר על השיטות השונות לשימוש באופרטור Bitwise left shift (<<) על ערכי מספר שלם ארוך.
שימוש במערכת;תוכנית כיתה_3
{
ריק סטטי ראשי ( ) {
מספר ארוך_0 = ארבע חמש ;
מספר ארוך_1 = 5 ;
קונסולה.כתוב ( 'המשמרת השמאלית של ארוך היא' ) ;
Console.WriteLine ( מספר_0 << 3 ) ;
קונסולה.כתוב ( 'המשמרת השמאלית של ארוך היא' ) ;
קונסולה.כתוב ( מספר_0 << Convert.ToInt16 ( מספר 1 ) ) ;
}
}
האתחול של שני משתנים ארוכים מסוג מספר שלם, 'number_0' ו-'number_1', נעשה במשפט הראשון. הפעל את הפונקציה Console.Write() כדי לייצג את ההודעה 'The left shift of long is' ואת התוצאה בטרמינל. כאן, אנו מיישמים את אופרטור המשמרת השמאלי (<<) בצורה כזו שנמקם את האופרנד הראשון כמשתנה הראשון ואת האופרנד השני כערך שלם. המהדר שמאלה מעביר את האופרנד הראשון שהוא 'number_0' ב-3 ומציג את התוצאה. בהצהרה הבאה, הדפס הודעה נוספת על המסך על ידי שימוש בשיטת Console.Write() . כאן, אנו משתמשים במשתנה הראשון, 'number_0', בתור האופרנד הראשון והמשתנה השני, 'number_1', בתור האופרנד השני. האופרנד השני חייב להיות ערך מסוג מספר שלם. אנו משדרים את המשתנה השני 'number_1' לסוג המספרים השלמים באמצעות הפונקציה Convert.ToInt16() . לאחר מכן, הצג את התוצאה במסוף:
דוגמה 4:
קוד זה מראה כיצד אנו יכולים להקצות את הערכים למספר שלם לאחר ביצוע ההזזה השמאלית באופרטור הארוך ללא סימן.
שימוש במערכת;תוכנית כיתה_4
{
ריק סטטי ראשי ( ) {
head number_0 = 445 ;
קונסולה.כתוב ( 'ההזזה השמאלית של אולונג היא' ) ;
Console.WriteLine ( מספר_0 << 8 ) ;
קונסולה.כתוב ( 'ההזזה השמאלית של אולונג היא' ) ;
Console.WriteLine ( מספר_0 << 16 ) ;
קונסולה.כתוב ( 'ההזזה השמאלית של אולונג היא' ) ;
Console.WriteLine ( מספר_0 << 32 ) ;
}
}
ראשית, הכריז על משתנה מסוג מספר שלם ארוך ללא סימן שהוא 'number_0'. לאחר מכן, הצג את הטקסט 'The left shift of ulong is' בטרמינל על ידי קריאה לשיטת Console.Write() . נמצא את ההזזה השמאלית של ה-'number_0' בערך שלם של 8 ואין לנו צורך לאחסן את התוצאה בשום מקום. הפונקציה Console.WriteLine() מדפיסה את התוצאה על המסוף. חזור על תהליך זה פעמיים ושנה את הערכים של האופרנד השני. על ידי כך נוכל למצוא את ההזזה שמאלה של ערך מסוג מספר שלם ארוך ללא סימן. אבל אם אנחנו רוצים לשמור את הערך המתקבל במשתנה, עלינו לחשוב שהתוצאה היא זהה לסוג האופרנד הראשון. ההבדל היחיד בין Console.Write() ל-Console.WriteLine() הוא שהפונקציה השנייה מדפיסה את התוצאה ושולחת את הסמן לשורה הבאה בעוד שהפונקציה הראשונה רק מדפיסה את התוצאה והסמן מהבהב באותה שורה גם לאחר הצגת הפלט.
סיכום
חקרנו את האופרטורים של Bitwise ב-C#, הסוגים והפונקציונליות שלהם. אופרטור ההזזה השמאלי (<<) מוחל כדי להזיז את המספר או הערך במספר מוגדר של סיביות שמאלה. האופרטורים של Bitwise משפרים את היעילות של הקוד וזה לא מכביד על המערכת מכיוון שהם מפעילים קלים. המעבד (יחידת עיבוד המחשב) שלנו עובד ברמת Bitwise בכל פעם שאנו מבצעים פעולות אריתמטיות כלשהן. בקיצור, האופרטורים של Bitwise חשובים בתכנות ו-C# תומך בכל האופרטורים של Bitwise שבהם אופרטור המשמרת השמאלי (<<) הוא אחד מהם.