בשפות תכנות, **אוֹפֵּרָטוֹר** (בעברית: **מפעיל, סימן פעולה**) הוא פונקציה הפועלת על יחידה תכנותית כלשהי (קבועים, משתנים, טיפוסים וכדומה), שתיקרא אופרנד, או על מספר אופרנדים, ומחזירה ערך מטיפוס מוגדר.
פונקציה זו נכתבת כתו או אוסף תווים (מילה) הנכתבים בסמוך לאופרנד או בין שני אופרנדים.
דוגמאות לאופרטורים נפוצים הן אופרטור החיבור **+** (בביטוי a**+**b) ואופרטור ההשמה (**=:** בפסקל).

למעשה, אופרטור בשפות תכנות הוא צורת תחביר שונה לפונקציה בעלת 1-3 ארגומנטים.
עיקר תפקידו של האופרטור בתכנות הוא לשפר את קריאות התוכנית, את הדמיון בינה לבין טקסט מתמטי, לוגי או שפה טבעית, או על מנת להדגיש משמעות של פעולה כלשהי.
האופרטורים הנפוצים הם על פי רוב כאלה שפעולתם מקבילה לפעולת אופרטור מתמטי כלשהו, כגון אופרטורים אריתמטיים: חיבור, כפל, חילוק וכדומה. בחלק מהמקרים משתמשים באופרטורים על מנת לסמן פעולות להן יש מיפוי ישיר אל פקודת מעבד בודדת (כגון פעולות אריתמטיות או פעולות על סיביות בזיכרון).

בשפות רבות כללי מתן השמות לאופרטורים שונים מאלה של מזהים אחרים בשפה, ומאפשרים סימונים מתמטיים ואחרים, אך גם מילה אנגלית עשויה להיחשב אופרטור בחלק משפות התכנות (למשל sizeof בשפת C, או not בפייתון).

תחביר
-----

ישנן שלוש דרכים לכתיבת אופרטורים:

* אינפיקס (infix, תוכי) - כתיבת האופרטור בין שני אופרנדים (או יותר) עליהם הוא פועל (כמו בדוגמת A+B שהוזכרה למעלה). זוהי הצורה הנפוצה.
* פרפיקס (prefix, תחילי) - כתיבת האופרטור משמאל לאופרנד עליו הוא פועל (למשל אופרטור הכתובת & בשפת C). שימוש בצורת prefix עבור יותר מאופרנד יחיד איננה נפוצה, אך שימושית בשפות סף ושפות מכונה.
* פוסטפיקס (postfix, סופי) - כתיבת האופרטור מימין לאופרנד עליו הוא פועל (למשל שימוש באופרטור הקידום בצורה ++x בשפת C). שימושיה דומים לאלה של prefix.
* כתיב פולני - צורת כתיבה זו איננה נפוצה בשפות שנועדו למתכנת אנושי, מכיוון שהיא קשה לשימוש ולקריאה, אך היא מקלה על הידור הקוד וביצועו ולכן שימושית בשפות מבוססות מחסנית ונכתבות על ידי מכונה, כמו שפת פוסטסקריפט.

אופרטור הפועל על אופרנד יחיד נקרא **אונרי**, אופרטור הפועל על שני אופרנדים נקרא **בינארי**.
בשפות מסוימות קיימים גם אופרטורים **טרינאריים**, הפועלים על שלושה אופרנדים. הדוגמה המוכרת ביותר היא אופרטור :? בשפת C ונגזרותיה, שנכתב בצורה (A ? B : C) ומשמעותו "אם A אמת אז B אחרת C". דוגמה נוספת היא האופרטור /\* בשפת Forth, שנכתב בתצורת postfix ומשמעו "הכפל את האיבר השלישי במחסנית באיבר השני במחסנית, וחלק את התוצאה באיבר הראשון במחסנית".

סוגי אופרטורים
--------------

ניתן לחלק את האופרטורים לפי תפקודם:

### אופרטורים אריתמטיים

אופרטורים אריתמטיים הם ככל הנראה האופרטורים הנפוצים ביותר בשל הכללת אופרטורי ארבע פעולות החשבון: כפל (\*), חילוק (/), חיבור (+) וחיסור\הפיכת סימן (-). לרוב נכתבים אופרטורים אלו בכתיב המקובל במתמטיקה. אופרטורים אריתמטיים שימושיים נוספים הם העלאה בחזקה (\*\*), שארית החילוק (%) וחילוק שלמים.

### אופרטורי השמה

קבוצה זו של אופרטורים מבצעים פעולות השמה אל תוך משתנים. האופרטור הידוע ביותר בהקשר זה הוא אופרטור השמה, הנכתב לרוב באמצעות סימן השווה (=) או בשילוב שלו עם תו נוסף.

בשפות תכנות שהושפעו מ-ALGOL 68 קיימים אופרטורים הכוללת פעולה מתמטית ופעולה השמה. כך לדוגמה, האופרטור (=+) (בדוגמה A += B) מקביל לפעולת ההשמה והחיבור A = A + B.  

ניתן להחשיב כל אופרטור הגורם לתוצאת לוואי על אחד האופרנדים שלו כאופרטור השמה, ובפרט אופרטור השמה עשוי להיות אונרי - למשל האופרטור ++ בשפת C, שמקדם משתנה המופיע לפניו או אחריו בערך אחד (עבור טיפוסים דיסקרטיים כגון מספרים שלמים), כך שהביטוי A++ שקול לביטוי A=A+1.

בשפות פונקציונליות בהן משתנים אינם משנים את תוכנם, קיימים אופרטורים (ובפרט האופרטור =) המשמשים ליצירת קישור (binding) בין מזהה לערך אותו הוא מקבל, או להגדרת ערך החזרה של פונקציה.

### אופרטורים השוואתיים

אופרטור השוואה הוא אופרטור הפועל על שני אופרנדים מטיפוס כלשהו, ומחזיר ערך בוליאני (אמת או שקר). בין פעולות ההשוואה ראוי לציין את הפעולות הנפוצות: שווה ל- (==), גדול מ- (<), קטן מ- (>), שונה מ- (=!), גדול או שווה ל- (=<) וכדומה. לדוגמה, הביטוי (A < B) יקבל ערך אמת אם B גדול מ-A, ושקר אחרת.

### אופרטורים לוגיים

 ערך מורחב – **פעולה בוליאנית**  

אופרטורים לוגיים משמשים לפעולה בין ביטויים מטיפוס בוליאני, וכל אופרטור כזה מייצג טבלת אמת כלשהי. דוגמאות לאופרטורים אלו: וגם (סימונים נפוצים: &, &&, ^, and), או (סימונים נפוצים: |, ||, or), ושלילה (סימונים נפוצים: !, not, +\).

### אופרטורים על סיביות

אופרטורים הפועלים על סיביות. פעולות על סיביות מהירות ויעילות משמעותית מפעולות אריתמטיות ככפל וחילוק. קיימים אופרטורים שונים שמבצעות פעולות על סיביות בין שתי משתנים כמו NOT ,OR ,XOR ,AND כמו גם הזזת סיביות במשתנה אחד נתון.

### אופרטורים נוספים

בנוסף ישנם סוגי אופרטורים אחרים, שקיומם תלוי בשפת התכנות:

* אופרטורים לפעולה על מחרוזות, למשל האופרטור "שרשור" (לרוב &, &&, + או ++) המשמש ליצירת מחרוזת חדשה משתי מחרוזות על ידי הצמדת השנייה אל הקצה של הראשונה.
* אופרטורים לטיפול בזיכרון (קריאה וכתיבה) ואופרטורים של קלט ופלט מהמשתמש.
* אופרטורים של גישה לאינדקס במערך או ברשימה ([], !!).
* אופרטור מצביע ל"חברים" של אובייקטים (. או <- ).
* אופרטורי תחום הכרזה (Scope) - למשל האופרטור **::** ב++C - באמצעותם ניתן להבדיל בין משתנים מתחומים שונים, ולמנוע התנגשות בין שמות או אי בהירות.
* אופרטורים הבודקים מאפיינים שונים באופרנד, כגון האם אובייקט הוא מטיפוס כלשהו, או ירש מטיפוס כלשהו, מה גודל הזיכרון אותו האובייקט תופס, וכדומה. לדוגמה האופרטור instanceof בשפת ג'אווה.
* אופרטורים המבצעים המרה של ערכים מטיפוס לטיפוס, או שמשנים את התייחסות המהדר לאובייקט מסוים כאילו הוא מטיפוס אחר.
* אופרטורי תנאי כמו האופרטור  : ? בשפת C, שהוזכר לעיל.
* בשפות מונחות עצמים קיימים לעיתים אופרטורים כגון new, delete המטפלים ביצירת אובייקטים והריסתם.

קיימים סוגים נוספים של אופרטורים נדירים יותר שלא נמצאים בשימוש נרחב.

העמסת אופרטורים
---------------

חלק משפות התכנות מאפשרות למתכנת לבצע העמסת אופרטורים, כלומר להגדיר אותם כך שיפעלו על טיפוסים נוספים, או להגדיר להם פעולות שונות מאלו שנקבעו בשפה. לדוגמה, בשפת ++C אופרטור + משמש לפעולה חשבונית בין מספרים, אך מוגדר לעיתים לביצוע פעולות שרשור מחרוזות או לחיבור בין מערכים.
תכונה זו איננה מוגבלת לתכנות מונחה עצמים. ישנן שפות שאינן מונחות עצמים (כמו LISP) המאפשרות העמסת אופרטורים, ושפות מונחות עצמים (כגון Java) שנמנעות מלספק את האפשרות הזאת (לצורכי בהירות וחד משמעיות).

חלק מהשפות מאפשרות למתכנת לבצע העמסת אופרטורים רק על קבוצת האופרטורים שהוגדרה מראש על ידי השפה. בשפות אחרות ניתן ליצור אופרטורים חדשים, אף כאלו שלא הוגדרו על ידי השפה.

להלן חלוקה של שפות תכנות נפוצות על פי מידת הגמישות בהעמסת אופרטורים:

|  | העמסה לא אפשרית | העמסה אפשרית |
| --- | --- | --- |
| קבוצה  מוגבלת  מראש | * BASIC
* C
* פסקל
* Visual Basic
* Java
* JavaScript
* Objective-C
* PHP
 | * עדה
* ++C
* #C
* D
* Perl
* פייתון
* דלפי, מאז 2005
* Visual Basic 2005
 |
| ניתן להגדיר חדשים | * ML
* Pico
 | * ALGOL 68
* Fortran
* Haskell
* LISP
* Prolog
* Ruby
* Perl 6
* Smalltalk
* Eiffel
 |

קדימות
------

קדימות אופרטורים (Associativity) מציינת את חוזק הקשר בין הביטויים השונים. והיא נקבעת הן לפי סדר עדיפויות קבועה מראש בין האופרטורים השונים, והן לפי הסדר שבו הם כתובים (משמאל לימין או ימין לשמאל). כך למשל, האסוציאטיביות המקובלת בפעולות אריתמטיות היא שפעולת העלאה בחזקה קודמת לכפל וחילוק שקודמות לפעולות חיבור וחיסור, וכן מקובל שפעולות אלה קודמות לפעולת השמה.

במקרה של ספק או רצון לחרוג מסדר העדיפויות, ניתן על פי רוב להשתמש בסוגריים שקובעים את סדר הקדימויות הרצוי (לדוגמה: ערכו של הביטוי 2+2\*3 הוא 8 ואילו (2+2)\*3 הוא 12). אך יש לשים לב לכך ששימוש זה בסוגריים שונה מהשימוש בהם כ**אופרטור קריאה לפונקציה** בשפות תכנות רבות, וכן לכך שבשפות מסוימות (למשל Haskell) הדבר עלול לתת משמעות שונה מהצפוי לביטוי כולו.

כאשר ישנם בביטוי מספר אופרטורים להם עדיפות שווה, העדיפות תקבע על פי סדר הכתיבה שלהם, לעיתים הקדימות היא של האיבר השמאלי מביניהם ולעיתים של הימני, באופן שתלוי בהקשר ובשפה הספציפית. ישנם מקרים מעטים בהם אין סדר עדיפויות (כמו אופרטורים בוליאניים בשפת עדה) ובמספר שפות כגון פרולוג ניתן לשנות את הסדר הקבוע מראש.

בכתיבה postfix או prefix סדר הפעולות נקבע באופן יחיד, ולכן אין משמעות לקדימות בין האופרטורים.

ראו גם
------

* אופרטור מתמטי.

קישורים חיצוניים
----------------

ויקישיתוף מדיה וקבצים בנושא **אופרטור** בוויקישיתוף