Operators

Arithmetic Operators

Unary and binary operators

A unary operator (also called a monadic operator) is an operator with only one operand, while a binary operator (also called a dyadic operator) has two operands. For example, the plus sign in 1 + 2 is a binary operator, with 1 and 2 as its two operands. In addition, C++ has exactly one ternary operator, ?:.

Among arithmetic operators, there are two unary operators (unary plus and unary minus) and five binary operators (multiplication, division, modulo, addition, and subtraction). Unary operators have the highest precedence.

The modulo operator % means calculating the remainder obtained by dividing two integers, that is, finding the remainder.

When - is a binary operator, it performs subtraction, as in 2-1; when it is a unary operator, it performs negation, as in -1.

It is used as follows:

op=x-y*z

its value computed by op follows the usual mathematical precedence of addition, subtraction, multiplication, and division: operations with higher precedence are performed first; operations with equal precedence are performed according to associativity; and parentheses increase precedence.

Type Conversion in Arithmetic Operations

For binary arithmetic operators, when the types of the two variables involved in an operation are the same, no type conversion occurs, and the outcome is stored using the type of the participating variables. Otherwise, type conversion occurs so that the types of the two variables become consistent. See type conversion for the conversion rules.

For example, consider an integer (int) variable $x$ and another variable $y$ of type double-precision floating point (double):

• Evaluating x/3 is an integer;
• Evaluating x/3.0 is a double-precision floating-point value;
• Evaluating x/y is a double-precision floating-point value;
• Evaluating x*1/3 is an integer;
• Evaluating x*1.0/3 is a double-precision floating-point value;

Bitwise Operators

See also: Bitwise Operations.

For the meaning of bitwise operations, see the Bitwise Operations page. Note that bitwise operations have lower precedence than arithmetic operators (except for bitwise NOT), while bitwise AND, bitwise OR, and XOR have lower precedence than comparison operators (see the complete C++ operator precedence table). Therefore, take extra care when using them and add parentheses when necessary.

The behavior of a shift operation is undefined in the following cases:

1. The right operand (that is, the number of positions to shift) is negative;
2. The right operand is greater than or equal to the number of bits in the left operand;

For example, for a variable a of type int32_t, both a<<-1 and a<<32 are undefined.

For a left-shift operation on a signed nonnegative number, you must ensure that the shifted result can be represented by the original type; otherwise, the behavior is also undefined.¹ Performing a left shift on a negative number is also undefined.²

For a right-shift operation, excess bits on the right are discarded, while the behavior on the left is more complicated: for unsigned numbers, $0$ is added on the left³; for signed numbers, the most significant bit (which is the sign bit: $0$ for nonnegative numbers and $1$ for negative numbers) is replicated to fill the left side⁴.

Increment/Decrement Operators

Sometimes we need to increase a variable by 1 (increment) or decrease it by 1 (decrement). This is where the increment operator ++ and decrement operator -- come in handy.

Increment/decrement operators can be placed before or after a variable. They are called prefixes when placed before a variable and suffixes when placed after it. When used alone, prefixes and suffixes need no special distinction; if its value from that expression is used, however, attention is required. See the examples below for details. For more information, see the examples section of the introduction to references.

i = 100;

op1 = i++;  // op1 = 100, first op1 = i, then i = i + 1

i = 100;

op2 = ++i;  // op2 = 101, first i = i + 1, then assign op2

i = 100;

op3 = i--;  // op3 = 100, first assign op3, then i = i - 1

i = 100;

op4 = --i;  // op4 = 99, first i = i - 1, then assign op4

Compound Assignment Operators

Compound assignment operators are actually abbreviated forms of expressions. They can be divided into compound arithmetic operators +=, -=, *=, /=, %= and compound bitwise operators &=, |=, ^=, <<=, >>=.

For example, op = op + 2 can be written as op += 2, op = op - 2 can be written as op -= 2, and op= op * 2 can be written as op *= 2.

Conditional Operator

The conditional operator can be regarded as an abbreviation for an if statement. In a ? b : c, if expression a is true, the outcome of the conditional expression is b; otherwise, the outcome is c.

Comparison Operators

In particular, note that the equality operator == must be distinguished from the assignment operator =. This is especially important in conditional statements.

if (op=1) and if (op==1) look similar, but their actual functions differ greatly. The first statement assigns a value to op; if the assigned value is nonzero, it is true, so that condition of that expression is always satisfied and cannot serve as a test. The second statement is the one that tests its value from op.

Logical Operators

Result = op1 && op2;  // Result is true when both op1 and op2 are true

Result = op1 || op2;  // Result is true when either op1 or op2 is true

Result = !op1;  // Result is true when op1 is false

The built-in operators && and || perform short-circuit evaluation (if the outcome is already known after evaluating the first operand, the second operand is not evaluated). Overloaded operators do not have this property and always evaluate both operands.

Comma Operator

The comma operator separates multiple expressions. The separated expressions are evaluated in order from left to right, and its value from the entire expression is its value from the last expression. The comma expression has the lowest precedence of all operators.

exp1, exp2, exp3;  // The final value is the outcome of evaluating exp3.

Result = 1 + 2, 3 + 4, 5 + 6;
// Result is 3 rather than 11, because the assignment operator "=" has higher precedence
// than the comma operator, so assignment is performed before the comma operations.

Result = (1 + 2, 3 + 4, 5 + 6);

// To make its value from Result be the outcome of the comma operation, the entire expression
// should be enclosed in parentheses to increase its precedence. Only then is its value from Result 11.

Member Access Operators

These operators are used to access members or memory of an object. Except for the last operator, all of the operators above can be overloaded. For material related to &, *, and ->, read the Pointers and References tutorials. Two rarely used operators, .* and ->*, are omitted here; for their specific usage, see the C++ language reference.

auto result1 = v[1];  // Get the object whose subscript in v is 2
auto result2 = p.q;   // Get member q of object p
auto result3 = p -> q;  // Get member q of the object pointed to by p, equivalent to (*p).q
auto result4 = &v;      // Get the pointer to v
auto result5 = *v;      // Get the object pointed to by pointer v

Complete C++ Operator Precedence Table

From C++ operator precedence - cppreference, with modifications.

Note that the table does not list operators such as const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, sizeof..., noexcept, and alignof, because their syntax is the same as a function call and cannot be ambiguous.

References and notes

Footnotes

1. Before C++20, if the original value had a signed type and the shifted result could be represented by the unsigned version of the original type, the outcome was converted to the corresponding signed value; otherwise, the behavior was undefined. For left shifts of unsigned numbers, bits shifted out of the outcome type were discarded. Starting with C++20, a << b is specified as its value from $a\cdot 2^b$ modulo $2^N$ ($N$ is the bit width of the outcome type), meaning that for both signed and unsigned numbers, a left shift directly discards bits shifted out of the outcome type (that is, arithmetic left shift / logical left shift). ↩

2. Before C++20. See ¹ for behavior starting with C++20. ↩

3. That is, logical right shift. ↩

4. That is, arithmetic right shift. Before C++20, right shifting a signed number was implementation-defined; most implementations used arithmetic right shift. Starting with C++20, a >> b is specified as $\lfloor a/2^b\rfloor$, so right-shifting a signed number is an arithmetic right shift. ↩