Operators in C and C++
This is a list of operators in the C++ and C programming languages. All the operators listed exist in C++; the third column indicates whether an operator is also present in C. It should also be noted that C does not support operator overloading.
The following operators are sequence points in both languages (when not overloaded): &&, ||, ?:, and , (the comma operator).
C++ also contains the type conversion operators const_cast, static_cast, dynamic_cast, and reinterpret_cast which are not listed in the table for brevity. The formatting of these operators means that their precedence level is unimportant.
Those operators that are in C, with the exception of the comma operator and the arrow operator, are also in Java, Perl, C#, and PHP with the same precedence, associativity, and semantics, with one exception: ternary operator associativity in PHP is left-to-right.
Operator precedence
The following is a table that lists the precedence and associativity of all the operators in the C++ programming language. Operators are listed top to bottom in descending precedence and operators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same precedence, in the given direction.
The syntax of expressions in C and C++ is specified by a context-free grammar. The table given here has been inferred from the grammar.
A precedence table, while mostly adequate, cannot resolve a few details. In particular, note that the ternary operator allows any arbitrary expression as its middle operand, despite being listed as having higher precedence than the assignment and comma operators. Thus a ? b , c : d
is interpreted as a ? (b, c) : d
, and not as the meaningless (a ? b), (c : d)
. Also, note that the immediate, unparenthesized result of a C cast expression cannot be the operand of sizeof
. Therefore, sizeof (int) * x
is interpreted as (sizeof(int)) * x
and not sizeof ((int) *x)
.
Operator(s) | Description | Associativity |
---|---|---|
::
|
Scope resolution (C++ only) | Left-to-Right |
++ -- () [] . -> typeid() const_cast dynamic_cast reinterpret_cast static_cast
|
Postfix increment and decrement Function call Array subscripting Element selection by reference Element selection through pointer Run-time type information (C++ only) Type cast (C++ only) Type cast (C++ only) | |
++ -- + - ! ~ (type) * & sizeof new new[] delete delete[]
|
Prefix increment and decrement Unary plus and minus Logical NOT and bitwise NOT Type cast Indirection (dereference) Address-of (reference) Size-of Dynamic memory allocation (C++ only) Dynamic memory deallocation (C++ only) |
Right-to-Left |
.* ->*
|
Pointer to member (C++ only) | Left-to-Right |
* / %
|
Multiplication, division, and modulus (remainder) | |
+ -
|
Addition and subtraction | |
<< >>
|
Bitwise left shift and right shift | |
< <= > >=
|
Relational “less than” and “less than or equal to” Relational “greater than” and “greater than or equal to” | |
== !=
|
Relational “equal to” and “not equal to” | |
&
|
Bitwise AND | |
^
|
Bitwise XOR (exclusive or) | |
|
|
Bitwise OR (inclusive or) | |
&&
|
Logical AND | |
||
|
Logical OR | |
c?t:f
|
Ternary conditional (see ?:) | Right-to-Left |
= += -= *= /= %= <<= >>= &= ^= |=
|
Direct assignment Assignment by sum and difference Assignment by product, dividend, and remainder Assignment by bitwise left shift and right shift Assignment by bitwise AND, XOR, and OR | |
throw
|
Throw operator (exceptions throwing, C++ only) | Not available |
,
|
Comma | Left-to-Right |
Table
For the purposes of this table, a
, b
, and c
represent valid values (literals, values from variables, or return value), object names, or lvalues, as appropriate.
Arithmetic operators | |||
Operator Name | Syntax | Overloadable | Included in C |
---|---|---|---|
Unary Plus | +a |
Yes | Yes |
Addition (Sum) | a + b |
Yes | Yes |
Prefix Increment | ++a |
Yes | Yes |
Postfix Increment | a++ |
Yes | Yes |
Assignment by Addition | a += b |
Yes | Yes |
Unary Minus (Negation) | -a |
Yes | Yes |
Subtraction (Difference) | a - b |
Yes | Yes |
Prefix Decrement | --a |
Yes | Yes |
Postfix Decrement | a-- |
Yes | Yes |
Assignment by Subtraction | a -= b |
Yes | Yes |
Multiplication (Product) | a * b |
Yes | Yes |
Assignment by Multiplication | a *= b |
Yes | Yes |
Division (Quotient) | a / b |
Yes | Yes |
Assignment by Division | a /= b |
Yes | Yes |
Modulus (Remainder) | a % b |
Yes | Yes |
Assignment by Modulus | a %= b |
Yes | Yes |
Comparison operators | |||
Operator Name | Syntax | Overloadable | Included in C |
Less Than | a < b |
Yes | Yes |
Less Than or Equal To | a <= b |
Yes | Yes |
Greater Than | a > b |
Yes | Yes |
Greater Than or Equal To | a >= b |
Yes | Yes |
Not Equal To | a != b |
Yes | Yes |
Equal To | a == b |
Yes | Yes |
Logical Negation | !a |
Yes | Yes |
Logical AND | a && b |
Yes | Yes |
Logical OR | a || b |
Yes | Yes |
Bitwise operators | |||
Operator Name | Syntax | Overloadable | Included in C |
Bitwise Left Shift | a << b |
Yes | Yes |
Assignment by Bitwise Left Shift | a <<= b |
Yes | Yes |
Bitwise Right Shift | a >> b |
Yes | Yes |
Assignment by Bitwise Right Shift | a >>= b |
Yes | Yes |
Bitwise One's Complement | ~a |
Yes | Yes |
Bitwise AND | a & b |
Yes | Yes |
Assignment by Bitwise AND | a &= b |
Yes | Yes |
Bitwise OR | a | b |
Yes | Yes |
Assignment by Bitwise OR | a |= b |
Yes | Yes |
Bitwise XOR | a ^ b |
Yes | Yes |
Assignment by Bitwise XOR | a ^= b |
Yes | Yes |
Other operators | |||
Operator Name | Syntax | Overloadable | Included in C |
Basic Assignment | a = b |
Yes | Yes |
Function Call | a() |
Yes | Yes |
Array Subscript | a[b] |
Yes | Yes |
Indirection (Dereference) | *a |
Yes | Yes |
Address-of (Reference) | &a |
Yes | Yes |
Member by Pointer | a->b |
Yes | Yes |
Member | a.b |
No | Yes |
Member by Pointer Indirection | a->*b |
Yes | No |
Member Indirection | a.*b |
No | No |
Cast | (type) a |
Yes | Yes |
Comma | a , b |
Yes | Yes |
Ternary Conditional | a ? b : c |
No | Yes |
Scope Resolution | a::b |
No | No |
Size-of | sizeof a sizeof(type) |
No | Yes |
Type Identification | typeid(a) typeid(type) |
No | No |
Allocate Storage | new type |
Yes | No |
Allocate Storage (Array) | new type[n] |
Yes | No |
Deallocate Storage | delete a |
Yes | No |
Deallocate Storage (Array) | delete[] a |
Yes | No |
Language extensions | |||
Operator Name | Syntax | Overloadable | Vendor |
Label Value | && label |
? | GCC |
Notes
Many of the operators containing multi-character sequences are given "names" built from the operator name of each character. For example, +=
and -=
are often called plus equal(s) and minus equal(s), instead of the more verbose "assignment by addition" and "assignment by subtraction".
The binding of operators in C and C++ is specified (in the corresponding Standards) by a factored language grammar, rather than a precedence table. This creates some subtle conflicts. For example, in C, the syntax for a conditional expression is:
logical-OR-expression ? expression : conditional-expression
while in C++ it is:
logical-or-expression ? expression : assignment-expression
Hence, the expression:
e = a ? b : c = d
is parsed differently in the two languages. In C, this expression is parsed as:
e = ((a ? b : c) = d)
which is a semantic error, since the result of a conditional-expression is not an lvalue. In C++, it is parsed as:
e = (a ? b : (c = d))
which is a valid expression.
The precedence of the bitwise logical operators has been criticized.[1] Conceptually, & and | are arithmetic operators like + and *. But the expression
a & b == 7
means
a & (b == 7) ,
while
a + b == 7
means
(a + b) == 7 .
This requires parentheses to be used more often than they otherwise would.
C++ operator synonyms
C++ defines keywords to act as aliases for a number of symbols that function as operators: and (&&), bitand (&), and_eq (&=), or (||), bitor (|), or_eq (|=), xor (^), xor_eq (^=), not (!), not_eq (!=), compl (~)
. These are parsed exactly like their symbolic equivalents, and can be used in place of the symbol they replace. It is the punctuation that is aliased, not the operators. For example, bitand can replace both the bitwise AND operator and the address-of operator.
C provides the header file iso646.h, which defines these symbols as preprocessor macros which expand to the values these symbols take on in C++. For compatibility with C, C++ provides the header ciso646 for which inclusion has no effect.
External links
- C Operators
- Experimental results showing that developers have poor knowledge of binary operator precedence.
- Basic types & Operators