Operators
Operators fall into broad classifications according to their primary use.
|
Assignment operators |
=, +=, *=, ... |
|
Arithmetic operators |
+, -, *, /, % |
|
Relational operators |
<, <=, >, >=, ==, != |
|
Logical operators |
&&, ||, ! |
|
Bitwise operators |
&, |, ^, ~, <<, >> |
|
Memory management operators |
new, delete, sizeof |
|
Pointer and access operators |
*, &, ., ->, [] |
|
Scope resolution operators |
:: |
|
Miscellaneous operators |
conditional (?:), comma (,) |
Operators have predefined meanings for built-in types, but not all operators are defined for all built-in types.
Operator Characteristics
Operators have the following special characteristics:
- Precedence
- Associativity
- Number of required operands
Table 19.1 lists all the C++ operators and their characteristics, grouped by precedence and purpose, with groups of highest precedence listed first.
- The Operands column contains the number of operands that the operator requires.
- The Description column contains the conventional meaning of the operator for built-in types.
- The Assoc column indicates the associativity that governs how an expression is evaluated if the same operator occurs more than once.
- L indicates left-to-right associativity. Example:
d = a + b + c; // a+b is evaluated first, then (a+b)+c
assignment is evaluated last because of lower precedence.
- R indicates right-to-left associativity:
c = b = a; // a is assigned to b, then to c.
- L indicates left-to-right associativity. Example:
- The Ovl column indicates whether or not the operator may be overloaded (redefined) for custom types.
- The possible values for that column are:
- Y: This operator can be overloaded as a global or member function.
- M: This operator can be overloaded only as a class member function.
- N: This operator cannot be overloaded.
|
Operator |
Operands |
Description |
Example |
Assoc |
Ovl |
|---|---|---|---|---|---|
|
:: |
one |
Global Scope Resolution |
:: name |
R |
N |
|
:: |
two |
Class/namespace scope resolution |
className::memberName |
L |
N |
|
-> |
two |
Member selector via ptr |
ptr->memberName |
L |
N |
|
. |
two |
Member selector via obj |
obj.memberName |
L |
N |
|
-> |
one |
Smart ptr |
obj->member |
R |
M |
|
[ ] |
two |
Subscript operator |
ptr[expr] |
L |
M |
|
( ) |
any[a] |
Function call |
function(argList) |
L |
N |
|
( ) |
any |
Value construction |
className(argList) |
L |
M |
|
++ |
one |
Post increment |
varName++ |
R |
Y |
|
-- |
one |
Post decrement |
varName-- |
R |
Y |
|
typeid |
one |
Type identification |
typeid(type) or typeid(expr) |
R |
N |
|
dynamic_cast |
two |
runtime checked conv |
dynamic_cast<type>(expr) |
L |
N |
|
static_cast |
two |
compile time checked conv |
static_cast<type>(expr) |
L |
N |
|
reinterpret_cast |
two |
unchecked conv |
reinterpret_cast<type>(expr) |
L |
N |
|
const_cast |
two |
const conv |
const_cast<type>(expr) |
L |
N |
|
sizeof |
one |
Size in bytes |
sizeof expr or sizeof(type) |
R |
N |
|
++ |
one |
Pre Increment |
++varName |
R |
Y |
|
-- |
one |
Pre Decrement |
--varName |
R |
Y |
|
~ |
one |
Bitwise negation |
~ expr |
R |
Y |
|
! |
one |
Logical negation |
! expr |
R |
Y |
|
+, - |
one |
Unary plus, unary minus |
+expr or -expr |
R |
Y |
|
* |
one |
Pointer dereference |
* ptr |
R |
Y |
|
& |
one |
Address-of |
& lvalue |
R |
Y |
|
new |
one |
Allocate |
new type or new type(expr-list) |
R |
Y |
|
new [ ] |
two |
Allocate array |
new type [ size ] |
L |
Y |
|
delete |
one |
Deallocate |
delete ptr |
R |
Y |
|
delete [ ] |
one |
Deallocate array |
delete [ ] ptr |
R |
M |
|
( ) |
two |
C-style type cast |
( type ) expr |
R |
N[b] |
|
->* |
two |
Member ptr selector via ptr |
ptr->*ptrToMember |
L |
M |
|
.* |
two |
Member ptr selector via obj |
obj.*ptrToMember |
L |
N |
|
* |
two |
Multiply |
expr1 * expr2 |
L |
Y |
|
/ |
two |
Divide |
expr1 / expr2 |
L |
Y |
|
% |
two |
Remainder |
expr1 % expr2 |
L |
Y |
|
+ |
two |
Add |
expr1 + expr2 |
L |
Y |
|
- |
two |
Subtract |
expr1 - expr2 |
L |
Y |
|
<< |
two |
Bitwise left shift |
expr << shiftAmt |
L |
Y |
|
>> |
two |
Bitwise right shift |
expr >> shiftAmt |
L |
Y |
|
< |
two |
Less than |
expr1 < expr2 |
L |
Y |
|
<= |
two |
Less or equal |
expr1 <= expr2 |
L |
Y |
|
> |
two |
Greater |
expr1 > expr2 |
L |
Y |
|
>= |
two |
Greater or equal |
expr1 >= expr2 |
L |
Y |
|
== |
two |
Equal[c] |
expr1 == expr2 |
L |
Y |
|
!= |
two |
Not equal |
expr1 != expr2 |
L |
Y |
|
& |
two |
Bitwise AND |
expr1 & expr2 |
L |
Y |
|
^ |
two |
Bitwise XOR (exclusive OR) |
expr1 ^ e2 |
L |
Y |
|
| |
two |
Bitwise OR (inclusive OR) |
expr1 | expr2 |
L |
Y |
|
&& |
two |
Logical AND |
expr1 && expr2 |
L |
Y |
|
|| |
two |
Logical OR |
expr1 || expr2 |
L |
Y |
|
= |
two |
Assign |
expr1 = expr2 |
R |
Y |
|
*= |
two |
Multiply and assign |
expr1 *= expr2 |
R |
Y |
|
/= |
two |
Divide and assign |
expr1 /= expr2 |
R |
Y |
|
%= |
two |
Modulo and assign |
expr1 %= expr2 |
R |
Y |
|
+= |
two |
Add and assign |
expr1 += expr2 |
R |
Y |
|
-= |
two |
Subtract and assign |
expr1 -= expr2 |
R |
Y |
|
<<= |
two |
Left shift and assign |
expr1 <<= expr2 |
R |
Y |
|
>>= |
two |
Right shift and assign |
expr1 >>= expr2 |
R |
Y |
|
&= |
two |
And and assign |
expr1 &= expr2 |
R |
Y |
|
|= |
two |
Inclusive or and assign |
expr1 |= expr2 |
R |
Y |
|
*= |
two |
Exclusive or and assign |
expr1 ^= expr2 |
R |
Y |
|
? : |
three |
Conditional expression |
bool ? expr : expr |
L |
N |
|
throw |
one |
Throw exception |
throw expr |
R |
N |
|
, |
two |
Sequential Evaluation (comma) |
expr , expr |
L |
Y |
[a] The function call operator may be declared to take any number of operands.
[b] The type-cast operator may use constructors or conversion operators to convert custom types.
[c] Note that for float and double, this operator should not be used, as it requires an "exact" match, which is architecture-dependent, and not always reliable.