C++ תומך במספר אופרטורים אונריים, כל אחד משרת מטרה ייחודית במניפולציה של המשתנים. נתחיל עם אופרטורי ההגדלה וההפחתה המשמשים בדרך כלל בלולאות ובאלגוריתמים שונים.
דוגמה 1: הגדלה (++) והקטנת (–) אופרטורים
האופרטורים האנריים תוספת (++) והקטנה (–) הם כלים בסיסיים ב-C++ לשינוי הערך של משתנה על ידי הגדלה או הקטנה שלו ב-1, בהתאמה. אופרטור ההגדלה (++) מוסיף 1 לערך המשתנה, בעוד שאופרטור ההקטנה (–) מפחית את 1. ניתן להחיל אופרטורים אלה על משתני מספר שלם, נקודה צפה ומצביע, מה שמספק גמישות בשימוש בהם.
הבה נחקור את האופרטורים הללו באמצעות דוגמה מעשית:
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int דֶלְפֵּק = 0 ;
// אופרטור הגדל
cout << 'ערך התחלתי: ' << דֶלְפֵּק << endl ;
דֶלְפֵּק ++ ;
cout << 'ערך לאחר תוספת: ' << דֶלְפֵּק << endl ;
// אופרטור הפחתה
דֶלְפֵּק -- ;
cout << 'ערך לאחר ירידה: ' << דֶלְפֵּק << endl ;
לַחֲזוֹר 0 ;
}
תוכנית C++ פשוטה זו כוללת את ספריית זרם הקלט/פלט הדרושה עם '#include
לאחר פעולה זו, הערך המעודכן של 'counter' מוצג באמצעות הצהרת 'cout' אחרת. לאחר מכן, אנו משתמשים באופרטור ההפחתה (מונה—) כדי להקטין את הערך של 'מונה' ב-1. התוצאה מוצגת לאחר מכן במסוף. בסופו של דבר, התוכנית מסתיימת ב'החזר 0;' הצהרה המעידה על ביצוע מוצלח.
תמונת הפלט מציגה את הערך ההתחלתי, הערך לאחר ההגדלה והערך המופחת.
דוגמה 2: אופרטורים חיוביים (+) ושליליים (-).
בעוד שהאופרטור האנרי החיובי משמש לעתים רחוקות, האופרטור השלילי הוא בסיסי לשינוי הסימן של משתנה.
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int ערך חיובי = 10 ;
int ערך שלילי = - ערך חיובי ;
cout << 'ערך חיובי:' << ערך חיובי << endl ;
cout << 'ערך שלילי: ' << ערך שלילי << endl ;
לַחֲזוֹר 0 ;
}
אנו מאתחלים שני משתנים שלמים עבור קוד לדוגמה זה שהם 'positiveValue' ו-'negativeValue'. ה-'positiveValue' מוקצה עם הערך של 10. לאחר מכן, אנו מצהירים על ה-'negativeValue' ומקצים אותו בשלילה של 'positiveValue' באמצעות האופרטור המינוס האנרי. אופרטור זה משנה למעשה את הסימן של הערך המקורי. לאחר מכן אנו משתמשים בהצהרת 'cout' כדי להציג הן את הפלט החיובי והן את הפלט השלילי בקונסולה. לבסוף, התוכנית מחזירה 0 המעיד על סיום מוצלח של הפונקציה הראשית.
בעת ביצוע, תוכנית זו מפיקה את הערכים החיוביים והשליליים.
דוגמה 3: מפעיל לא לוגי (!).
האופרטור האנרי ב-C++, מסומן ב-'!' סמל, ידוע בתור אופרטור NOT הלוגי. הוא נועד להפוך את ערך האמת של ביטוי נתון. הוא פועל על אופרנד בודד שהוא בדרך כלל ביטוי לוגי או תנאי. פעולת NOT הלוגית מניבה תוצאה 'אמיתית' כאשר האופרנד הוא 'שקר' ומניבה תוצאה 'שגויה' כאשר האופרנד הוא 'נכון'.
הנה דוגמה פשוטה שמדגימה את השימוש באופרטור NOT הלוגי:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
bool נכון = נָכוֹן ;
bool הוא שקר = שֶׁקֶר ;
bool resultNotTrue = ! נכון ;
bool resultNotFalse = ! הוא שקר ;
cout << 'ערך מקורי: ' << נכון << ', אחרי NOT: ' << resultNotTrue << endl ;
cout << 'ערך מקורי: ' << הוא שקר << ', אחרי NOT: ' << resultNotFalse << endl ;
לַחֲזוֹר 0 ;
}
בדוגמה זו, אנו מכריזים על שני משתנים בוליאניים, 'isTrue' ו-'isFalse'. לאחר מכן אנו מיישמים את האופרטור NOT הלוגי על כל משתנה, ומאחסנים את התוצאות ב-'resultNotTrue' ו-'resultNotFalse', בהתאמה. לאחר מכן, התוכנית מדפיסה את הערכים המקוריים ואת התוצאות של פעולת NOT הלוגית עבור שני המשתנים.
עם הפעלת תוכנית זו, נבחין כי האופרטור NOT הלוגי הופך את ערך האמת של 'isTrue' (בהתחלה הוגדר כ-true), והופך אותו ל-false. באופן דומה, הוא הופך את ערך האמת של 'isFalse' (שקר במקור), ומניב נכון.
הפלט ממחיש בבירור את ההיפוך של ערכי האמת שהושגו על ידי האופרטור NOT הלוגי.
דוגמה 4: אופרטור Bitwise NOT (~).
האופרטור Bitwise NOT (~) ב-C++ הוא אופרטור לא ארי המבצע שלילה סיבית של כל סיביות של האופרנד שלו. הוא פועל עם סוגי נתונים בסיסיים, במיוחד אינטגרליים, כגון מספרים שלמים. התוצאה מושגת על ידי היפוך של כל סיביות בודדות באופרנד, המרת 0s ל-1s ו-1s ל-0s.
כדי להמחיש את השימוש בו, שקול את קטע הקוד הבא:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int ערך מקורי = 5 ;
int resultBitwiseNot = ~ ערך מקורי ;
cout << 'ערך מקורי: ' << ערך מקורי << ', אחרי Bitwise NOT: ' << resultBitwiseNot << endl ;
לַחֲזוֹר 0 ;
}
בדוגמה זו, אנו מצהירים על משתנה מספר שלם 'originalValue' עם הערך '5'. לאחר מכן, אנו משתמשים באופרטור NOT bitwise (~) במשתנה זה. התוצאה של משתנה זה מאוחסנת ב-'resultBitwiseNot'. לאחר מכן, התוכנה מדפיסה את הערך המקורי ואת התוצאה לאחר פעולת NOT bitwise על ידי שימוש במשפט 'cout'.
כאשר נריץ את התוכנית הזו, נראה שהאופרטור NOT בשיטת הסיביות הופך כל סיביות של הייצוג הבינארי של 'ערך מקורי', וכתוצאה מכך נוצר ערך חדש.
דוגמה 5: מפעילי כתובת ועקיפה
האופרטור כתובת של, המסומן בסמל '&', משרת את המטרה של אחזור מיקום הזיכרון של משתנה. הוא מחזיר מצביע למשתנה המאפשר גישה עקיפה לערכו. אופרטור ההפניה או ההפניה (*) מקבל את הערך המאוחסן במיקום הזיכרון שצוין על ידי מצביע. הוא מספק דרך לעבוד עם הנתונים בפועל באמצעות מצביע בעקיפין.
בואו נבין את המושג באמצעות דוגמה:
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int ערך = 99 ;
cout << 'ערך מקורי: ' << ערך << endl ;
int * ptr = & ערך ;
cout << 'כתובת זיכרון:' << ptr << endl ;
int RetrievedValue = * ptr ;
cout << 'ערך מאוחזר:' << RetrievedValue << endl ;
לַחֲזוֹר 0 ;
}
קוד זה מדגים את השימוש באופרטורים של כתובת ועקיפה. ראשית, משתנה מספר שלם בשם 'value' מאותחל עם הערך של 99. הערך המקורי של 'value' מופק לאחר מכן למסוף. לאחר מכן, משתנה מצביע 'ptr' מוכרז, והאופרטור כתובת של (&) משמש כדי להקצות את כתובת הזיכרון של 'ערך' ל- 'ptr'. לאחר מכן, התוכנית מוציאה את כתובת הזיכרון הזו, ומציגה את הפעולה הבסיסית של מפעיל ה'כתובת'.
לאחר מכן, משתנה מספר שלם חדש שהוא 'retrievedValue' מוכרז, ואופרטור העקיפה (*) מופעל כדי לאחזר את הערך המאוחסן בכתובת הזיכרון שמצביעה על 'ptr'. הערך שאוחזר מופק לאחר מכן למסוף.
סיכום
מאמר זה סיפק חקירה מקיפה של אופרטורים אונריים ב-C++. התחלנו בסיווג האופרטורים האנריים לסוגים שונים כולל אריתמטיים, לוגיים, סיביים ואלו הקשורים לכתובת ולעקיפה. מצבים בעולם האמיתי הודגמו כדי להדגים את היישום השימושי של מפעילים אלה. אופרטורים אלה ממלאים תפקידים מרכזיים בתכנות C++ המאפשרים למפתחים לעבוד עם מצביעים ביעילות ולנהל את הזיכרון.