All listed operators are in C++ and lacking indication otherwise, in C as well. Some tables include a "In C" column that indicates whether an operator is also in C. Note that C does not support operator overloading.
When not overloaded, for the operators &&, ||, and , (the comma operator), there is a sequence point after the evaluation of the first operand.
Most of the operators available in C and C++ are also available in other C-family languages such as C#, D, Java, Perl, and PHP with the same precedence, associativity, and semantics.
Many operators specified by a sequence of symbols are commonly referred to by a name that consists of the name of each symbol. 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".
Operators
In the following tables, lower case letters such as a and b represent literal values, object/variable names, or l-values, as appropriate. R, S and T stand for a data type, and K for a class or enumeration type. Some operators have alternative spellings using digraphs and trigraphs or operator synonyms.
Arithmetic
C and C++ have the same arithmetic operators and all can be overloaded in C++.
All relational (comparison) operators can be overloaded in C++. Since C++20, the inequality operator is automatically generated if operator== is defined and all four relational operators are automatically generated if operator<=> is defined.[1]
C and C++ have the same logical operators and all can be overloaded in C++.
Note that overloading logical AND and OR is discouraged, because as overloaded operators they always evaluate both operands instead of providing the normal semantics of short-circuit evaluation.[2]
C++ defines keywords to act as aliases for a number of operators:[7]
Keyword
Operator
and
&&
and_eq
&=
bitand
&
bitor
|
compl
~
not
!
not_eq
!=
or
||
or_eq
|=
xor
^
xor_eq
^=
Each keyword is a different way to specify an operator and as such can be used instead of the corresponding symbolic variation. For example, (a > 0 and not flag) and (a > 0 && !flag) specify the same behavior. As another example, the bitand keyword may be used to replace not only the bitwise-and operator but also the address-of operator, and it can be used to specify reference types (e.g., int bitand ref = n).
The ISO C specification makes allowance for these keywords as preprocessor macros in the header file iso646.h. For compatibility with C, C++ also provides the header iso646.h, the inclusion of which has no effect. Until C++20, it also provided the corresponding header ciso646 which had no effect as well.
Expression evaluation order
During expression evaluation, the order in which sub-expressions are evaluated is determined by precedence and associativity. An operator with higher precedence is evaluated before a operator of lower precedence and the operands of an operator are evaluated based on associativity. The following table describes the precedence and associativity of the C and C++ operators. Operators are shown in groups of equal precedence with groups ordered in descending precedence from top to bottom (lower order is higher precedence).[8][9][10]
Operator precedence is not affected by overloading.
Although this table is adequate for describing most evaluation order, it does not describe a few details. 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). So, the expression in the middle of the conditional operator (between ? and :) is parsed as if parenthesized. Also, the immediate, un-parenthesized 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).
Chained expressions
The precedence table determines the order of binding in chained expressions, when it is not expressly specified by parentheses.
For example, ++x*3 is ambiguous without some precedence rule(s). The precedence table tells us that: x is 'bound' more tightly to ++ than to *, so that whatever ++ does (now or later—see below), it does it ONLY to x (and not to x*3); it is equivalent to (++x, x*3).
Similarly, with 3*x++, where though the post-fix ++ is designed to act AFTER the entire expression is evaluated, the precedence table makes it clear that ONLY x gets incremented (and NOT 3*x). In fact, the expression (tmp=x++, 3*tmp) is evaluated with tmp being a temporary value. It is functionally equivalent to something like (tmp=3*x, ++x, tmp).
Precedence and bindings
Abstracting the issue of precedence or binding, consider the diagram above for the expression 3+2*y[i]++. The compiler's job is to resolve the diagram into an expression, one in which several unary operators (call them 3+( . ), 2*( . ), ( . )++ and ( . )[ i ]) are competing to bind to y. The order of precedence table resolves the final sub-expression they each act upon: ( . )[ i ] acts only on y, ( . )++ acts only on y[i], 2*( . ) acts only on y[i]++ and 3+( . ) acts 'only' on 2*((y[i])++). It is important to note that WHAT sub-expression gets acted on by each operator is clear from the precedence table but WHEN each operator acts is not resolved by the precedence table; in this example, the ( . )++ operator acts only on y[i] by the precedence rules but binding levels alone do not indicate the timing of the postfix ++ (the ( . )++ operator acts only after y[i] is evaluated in the expression).
Binding
The binding of operators in C and C++ is specified 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:
To use the comma operator in a function call argument expression, variable assignment, or a comma-separated list, use of parentheses is required.[13][14] For example,
inta=1,b=2,weirdVariable=(++a,b),d=4;
Criticism of bitwise and equality operators precedence
The precedence of the bitwise logical operators has been criticized.[15] Conceptually, & and | are arithmetic operators like * and +.
The expression a&b==7 is syntactically parsed as a&(b==7) whereas the expression a+b==7 is parsed as (a+b)==7. This requires parentheses to be used more often than they otherwise would.
Historically, there was no syntactic distinction between the bitwise and logical operators. In BCPL, B and early C, the operators &&|| didn't exist. Instead &| had different meaning depending on whether they are used in a 'truth-value context' (i.e. when a Boolean value was expected, for example in if(a==b&c){...} it behaved as a logical operator, but in c=a&b it behaved as a bitwise one). It was retained so as to keep backward compatibility with existing installations.[16]
Moreover, in C++ (and later versions of C) equality operations, with the exception of the three-way comparison operator, yield bool type values which are conceptually a single bit (1 or 0) and as such do not properly belong in "bitwise" operations.
Notes
^The modulus operator only supports integer operands; for floating point, a function such as fmod can be used.
^ abcdThe int is a dummy parameter to differentiate between prefix and postfix.
^Possible return types: std::weak_ordering, std::strong_ordering and std::partial_ordering to which they all are convertible to.
^ abIn the context of iostreams in C++, writers often will refer to << and >> as the "put-to" or "stream insertion" and "get-from" or "stream extraction" operators, respectively.
^ According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,[3] use an arithmetic shift (i.e., sign extension), but a logical shift is possible.
^ According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,[3] use an arithmetic shift (i.e., sign extension), but a logical shift is possible.
^The actual address of an object with an overloaded operator & can be obtained with std::addressof
^The return type of operator->() must be a type for which the -> operation can be applied, such as a pointer type. If x is of type C where C overloads operator->(), x->y gets expanded to x.operator->()->y.
^The parentheses are not necessary when taking the size of a value, only when taking the size of a type. However, they are usually used regardless.[citation needed]
^C++ defines alignof operator, whereas C defines _Alignof (C23 defines both). Both operators have the same semantics.
^Behaves like const_cast/static_cast/reinterpret_cast. In the last two cases, the auto specifier is replaced with the type of the invented variable x declared with auto x(a); (which is never interpreted as a function declaration) or auto x{a};, respectively.
^For user-defined conversions, the return type implicitly and necessarily matches the operator name unless the type is inferred (e.g. operatorauto(), operatordecltype(auto)() etc.).
^The type name can also be inferred (e.g new auto) if an initializer is provided.
^The array size can also be inferred if an initializer is provided.
