Operator (computer programming)

This article is about operators in computer programming. For other uses, see Operator (disambiguation).

In computer programming, an operator is a programming language construct that provides functionality that may not be possible to define as a user-defined function (i.e. sizeof in C) or has syntax different than a function (i.e. infix addition as in a+b). Some languages allow a language-defined operator to be overridden with user-defined behavior and some allow for user-defined operator symbols.

Some operators are represented with symbols – characters typically not allowed for a function identifier. For example, a function that tests for greater-than could be named gt, but many languages provide an infix symbolic operator so that code looks more familiar. For example, this:

if gt(x, y) then return

Can be:

if x > y then return

Operators may also differ semantically from functions. For example, short-circuit Boolean operations evaluate later arguments only if earlier ones are not false.

Syntax

Many operators differ syntactically from user-defined functions. In most languages, a function is prefix notation with fixed precedence level and associativity and often with compulsory parentheses (e.g. Func(a) or (Func a) in Lisp). In contrast, many operators are infix notation and involve different use of delimiters such as parentheses.

In general, an operator may be prefix, infix, postfix, matchfix, circumfix or bifix ^{[1] [2] [3] [4] [5]} , and the syntax of an expression involving an operator depends on its arity (number of operands), precedence, and (if applicable), associativity. Most programming languages support binary operators and a few unary operators, with a few supporting more operands, such as the ?: operator in C, which is ternary. There are prefix unary operators, such as unary minus -x, and postfix unary operators, such as post-increment x++; and binary operations are infix, such as x + y or x = y. Infix operations of higher arity require additional symbols, such as the ternary operator  ?: in C, written as a ? b : c – indeed, since this is the only common example, it is often referred to as the ternary operator. Prefix and postfix operations can support any desired arity, however, such as 1 2 3 4 +.

Semantics

The semantics of operators particularly depends on value, evaluation strategy, and argument passing mode (such as Boolean short-circuiting). Simply, an expression involving an operator is evaluated in some way, and the resulting value may be just a value (an r-value), or may be an object allowing assignment (an l-value).

In simple cases this is identical to usual function calls; for example, addition x + y is generally equivalent to a function call add(x, y) and less-than comparison x < y to lt(x, y), meaning that the arguments are evaluated in their usual way, then some function is evaluated and the result is returned as a value. However, the semantics can be significantly different. For example, in assignment a = b the target a is not evaluated, but instead its location (address) is used to store the value of b – corresponding to call-by-reference semantics. Further, an assignment may be a statement (no value), or may be an expression (value), with the value itself either an r-value (just a value) or an l-value (able to be assigned to). As another example, the scope resolution operator  :: and the element access operator . (as in Foo::Bar or a.b) operate not on values, but on names, essentially call-by-name semantics, and their value is a name.

Use of l-values as operator operands is particularly notable in unary increment and decrement operators. In C, for instance, the following statement is legal and well-defined, and depends on the fact that array indexing returns an l-value:

x=++a[i];

An important use is when a left-associative binary operator modifies its left argument (or produces a side effect) and then evaluates to that argument as an l-value. ^[a] This allows a sequence of operators all affecting the original argument, allowing a fluent interface, similar to method cascading. A common example is the << operator in the C++ iostream library, which allows fluent output, as follows:

cout<<"Hello"<<" "<<"world!"<<endl;

Customization

Some languages (e.g. C, C++ and PHP) define a fixed set of operators, while others (e.g. Prolog, ^[6] Seed7, ^[7] F#, OCaml, Haskell) allow for user-defined operators. Some programming languages restrict operator symbols to special characters like + or := while others allow names like div (e.g. Pascal).

Most languages do not support user-defined operators since the feature significantly complicates parsing. ^[b] Many languages only allow operators to be used for built-in types, but some allow operators to be overloaded for user-defined types. Some languages allow new operators to be defined which may involve meta-programming (specifying the operators in a separate language). Definition of new operators, particularly runtime definition, often makes correct static analysis of programs impossible, since the syntax of the language may be Turing-complete, so even constructing the syntax tree may require solving the halting problem, which is impossible. This occurs for Perl, for example, and some dialects of Lisp.

Overloading

Main article: Operator overloading

Conceptually, an operator can be overloaded in the same way that a function can – acting differently based on the type of input. Some languages provide operators that are inherently overloaded (aka ad hoc polymorphic). For example, in Java the + operator sums numbers or concatenates strings. Some languages support user-defined operator overloading (such as C++).

Operand coercion

Further information: Type conversion

Some languages implicitly convert (aka coerce) operands to be compatible with each other. For example, Perl coercion rules cause 12 + "3.14" to evaluate to 15.14. The string literal "3.14" is converted to the numeric value 3.14 before addition is applied. Further, 3.14 is treated as floating point so the result is floating point even though 12 is an integer literal. JavaScript follows different rules so that the same expression evaluates to "123.14" since 12 is converted to a string which is then concatenated with the second operand.

In general, a programmer must be aware of the specific rules regarding operand coercion in order to avoid unexpected and incorrect behavior.

Examples

See also: Category:Operators (programming)

Examples of infix operators include:

• Arithmetic: such as addition, a+b
• relational: such as greater than, a>b
• Logic: such as a AND b or a&&b
• Assignment: such as a=b or a:=b
• Record or object field access: such as a.b
• Scope resolution: such as a::b or a.b

Less common operators include:

• Comma operator: e, f
• Dereference operator: *p and address-of operator: &x
• ?: or ternary operator: number = spell_out_numbers ? "forty-two" : 42
  • Elvis operator: x ?: y
• Null coalescing operator: x ?? y
• Spaceship operator (for three-way comparison): x <=> y
• Compound operators combining two or more atomic operations into one to simplify expressions, ease compiler optimizations depending on the underlying hardware implementation, or improve performance for speed or size. An example are the set of compound assignment operators (aka augmented assignments) in C/C++: +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |= Similarly, some digital signal processors provide special opcodes for fused operations like multiply–accumulate (MAC/MAD) or fused multiply–add (FMA) and some high-performance software libraries support functions like cis x = cos x + i sin x to boost processing speed or reduce code size.

Operator features in programming languages

The following table shows the operator features in several programming languages:

Language	Symbolic operators	Alphanumeric operators	Prefix	Infix	Postfix	Precedence	Associativity	Overloading	User-defined overloading	User-defined symbols
ALGOL 68 each symbolic operator has an alphanumeric equivalent and some a non-ASCII equivalent	+* ** * / % %* %× - + < <= >= > = /= & -:= +:= *:= /:= %:= %*:= +=: :=: :/=: non-ASCII:¬ +× ⊥ ↑ ↓ ⌊ ⌈ × ÷ ÷× ÷* □ ≤ ≥ ≠ ∧ ∨ ×:= ÷:= ÷×:= ÷*:= %×:= :≠:	not abs arg bin entier leng level odd repr round shorten i shl shr up down lwb upb lt le ge gt eq ne and or over mod elem minusab plusab timesab divab overab modab plusto is isnt	Yes	Yes	No	Yes (prefix operators always have priority 10)	Infix operators are left associative, prefix operators are right associative	Yes	Yes	Yes
APL	+ - × ÷ ⌈ ⌊ * ⍟ <nowiki>|</nowiki> ! ○ ~ ∨ ∧ ⍱ ⍲ &lt; ≤ = ≥ > ≠ . @ ≡ ≢ ⍴ , ⍪ ⍳ ↑ ↓ ? ⍒ ⍋ ⍉ ⌽ ⊖ ∊ ⊥ ⊤ ⍎ ⍕ ⌹ ⊂ ⊃ ∪ ∩ ⍷ ⌷ ∘ → ← / ⌿ \ ⍀ ¨ ⍣ & ⍨ ⌶ ⊆ ⊣ ⊢ ⍠ ⍤ ⌸ ⌺ ⍸	(requires ⎕ prefix)	Yes (first-order functions only)	Yes	Yes (higher-order functions only)	Higher-order functions precede first-order functions	Higher-order functions are left associative, first-order functions are right associative	Yes	Yes	Yes (alphanumeric only)
B	() [] ! ~ ++ -- + - * & / % << >> < <= > >= == != ^ <nowiki>|</nowiki> [[?:]] = =+ =- =* =/ =% =& =^ =<nowiki>|</nowiki> [8]		Yes	Yes	Yes	Yes	Yes	No	No	No
C	() [] -> . ! ~ ++ -- + - * & / % << >> < <= > >= == != ^ <nowiki>|</nowiki> && <nowiki>||</nowiki> [[?:]] = += -= *= /= %= &= ^=	sizeof	Yes	Yes	Yes	Yes	Yes	Yes	No	No
C++	(same as C)	(same as C plus) typeid new delete throw decltype static_cast dynamic cast reinterpret_cast const_cast	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No
C#	(same as C plus) ?.  ?[] ?? ??=	sizeof nameof new stackalloc await throw checked unchecked is as delegate default true false LINQ:from select where group...by group...by...into join...in...on...equals join...in...on...equals...into orderby orderby...descending Roslyn-only:__makeref __refvalue __reftype	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No
Java	(same as C)	new throw instanceof	Yes	Yes	Yes	Yes	Yes	Yes	No	No
Eiffel	[] + - * / // = /=	not and or implies "and then" "or else"	Yes	Yes	No	Yes	Yes	No	Yes	Yes
Haskell	+ - * / ^ ^^ ** == /= > < >= <= && || >>= >> $ $! . ++ !! :(and many more)	(function name must be in backticks)	Yes	Yes	No	Yes	Yes	Yes, using Type classes		Yes
Pascal	* / + - = < > <> <= >= :=	not div mod and or in	Yes	Yes	No	Yes	Yes	Yes	No	No
Perl	-> ++ -- ** ! ~ \ + - . =~ !~ * / % < > <= >= == != <=> ~~ & | ^ &&|| '	print sort chmod chdir rand and or not xor lt gt le ge eq ne cmp x	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No
PHP	[] ** ++ -- ~ @! [9] * / % + - . << >> < <= > >= == != === !== <> <=> & ^ | && || ?? ?: = += -= *= **= /= .= %= &= |= ^= <<= >>=	clone new unset print echo isset instanceof and or xor	Yes	Yes	Yes	Yes	Yes	No	No	No
PL/I	( ) -> + - * / ** > ¬> >= = ¬= <= < ¬< ¬ &|||		Yes	Yes	No	Yes	Yes	No	No	No
Prolog	:- ?- ; , . =.. = \= < =< >= > == \== - + / *	spy nospy not is mod	Yes	Yes	Yes	Yes	Yes	No	No	Yes
Raku	++ -- ** ! ~ ~~ * / + - . < > <= >= == != <=> & | ^ &&|| // [10]	print sort chmod chdir rand and or not xor lt gt le ge eq ne leg cmp x xx	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes [11]
Seed7	{} [] -> ** ! + - * / << >> & >< | = <> > >= < <= <& := +:= -:= *:= /:= <<:= >>:= &:= @:=	conv varConv parse conj div rem mdiv mod times mult in not and or digits lpad rpad lpad0	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Smalltalk	(up to two characters [12] )	(alphanumeric symbols need a colon suffix)	No	Yes	Yes	No	No	Yes	Yes	Yes
Swift	(any Unicode symbol string except) . (including) ! ~ + - * / % =+ =- =* =/ =% &+ &- &* =&+ =&- =&* && || << >> & | ^ == != < <= > >= ?? ... ..<	is as as?	Yes	Yes	Yes	Yes (defined as partial order in precedence groups)	Yes (defined as part of precedence groups)	Yes	Yes	Yes
Visual Basic .NET	() . ! ?() ?. ?! + - * / \ & << >> < <= > >= ^ <> = += -= *= /= \= &= ^= <<= >>=	New Await Mod Like Is IsNot Not And AndAlso Or OrElse Xor If(...,...) If(...,...,...) GetXmlNamespace(...) GetType(...) NameOf(...) TypeOf...Is TypeOf...IsNot DirectCast(...,...) TryCast(...,...) LINQ:From Aggregate...Into Select Distinct Where <Order By>...[Ascending|Descending] Take <Take While> Skip <Skip While> Let Group...By...Into Join...On <Group Join...On...Into>	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No

See also

• Operators in C and C++
• Relational operator

Notes

1. Conversely a right-associative operator with its right argument, though this is rarer.
2. Introducing a new operator changes the lexical specification of the language, which changes the lexical analysis. The arity and precedence of the operator is then part of the phrase syntax of the language, which changes the phrase-level analysis. For example, adding an operator @ requires lexing and tokenizing this character, and the phrase structure (syntax tree) depends on the arity and precedence of this operator.

References

1. "Operator Input Forms—Wolfram Language Documentation". reference.wolfram.com.
2. "Maxima 5.42.0 Manual: 7. Operators". maxima.sourceforge.net.
3. "Prefix, Postfix and Circumfix Operators". mythryl.org.
4. "Operators". doc.perl6.org.
5. Pribavkina; Rodaro (August 2010). Written at London Ontario. State Complexity of Prefix, Suffix, Bifix and Infix Operators on Regular Languages (Conference Article). Developments in Language Theory (14th International Conference ed.). Germany: Springer (published 2010). pp. 376–377. doi:10.1007/978-3-642-14455-4_34. ISBN   978-3-642-14454-7. ISSN   0302-9743.{{cite book}}: |journal= ignored (help)
6. "SWI-Prolog -- op/3". www.swi-prolog.org.
7. "Declare an operator". seed7.sourceforge.net.
8. "A TUTORIAL INTRODUCTION TO THE LANGUAGE B".
9. "PHP: Error Control Operators - Manual". php.net.
10. "Operators". docs.perl6.org.
11. "Functions". docs.perl6.org.
12. Goldberg, Adele. "Smalltalk-80: The Language and its Implementation, p. 27, ISBN 0-201-11371-6" (PDF).