CS211: Operators

= is the basic assignment operator. The left operand must be a lvalue while the right operand must have a rvalue. For the following examples, assume int x and int y have already been declared"

• x = 1 → 1 is now stored in the memory location tied to x
• x = y → The value tied to the memory location of y at the time of evaluation is now stored in the memory location tied to x

Without getting into too much theory, lvalues are locations in memory (variables, or pointer dereferences) whereas rvalues are data (which can include memory locations). The variable x returns an l or r value based on its surrounding context.

+ is the addition operator. It is used to add two numeric values.

• 4 + 2 → 6

- is the subtraction operator. It is used to subtract two numeric values.

• 4 - 2 → 2

- is also a unary operator to indicate a negative number. For example, -2 + 4 will also return 2.

*​ is the multiplication operator. It is used to multiply two numeric values.

• 4 * 2 → 8

/ is the division operator. It is used to divide two numeric values.

• 4 / 2 → 2

When two integers are involved integer division is performed. Functionally, that means the fractional result of the operation is removed. 2 / 4 equals 0.

% is the modulo operator. It is used to get the remainder after the left operand is divided by the right operand.

• 4 % 2 → 0 (2 goes into 4 two times with 0 remainder)
• 2 % 4 → 2 (4 goes into 2 0 times with 2 remainder)

Something that often trips students up is the fact that implicit conversion kicks in during the use of binary arithmetic operators. For example,

• 1 + 1.5 → double
• 1 + 1.5f → float
• 1 / 2.0 → double

And so on. In all of the above cases 1 is converted to the wider type.

> is the "greater than" operator. It is used to check if the left operand is greather than the right operand.

• 2 > 4 → 0

< is the "less than" operator. It is used to check if the left operand is less than the right operand.

• 2 < 4 → 1

>= is the "greater than or equal to" operator. It is used to check if the left operand is greater than or equal to the right operand.

• 2 >= 4 → 0
• 4 >= 4 → 1

<= is the "less than or equal to" operator. It is used to check if the left operand is less than or equal to the right operand.

• 2 <= 4 → 1
• 4 <= 4 → 1

== is the equality operator. It is used to check if the left operand is equal to the right operand.

• 2 == 4 → 0
• 2 == 2 → 1

Strict equality is dangerous when comparing floating point values! Relational operators should be used instead when dealing with floating points.

!= is the inequality operator. It is used to check if the left operand is not equal to the right operand.

• 2 != 4 → 1
• 2 != 2 → 0

&& is the logical AND operator. It is used for boolean conjunction where any non-zero value is considered to be true.

• 1 && 0 → 0
• 2 && -1 → 1

&& is guaranteed to be evaluated from left to right. This means that if the left operand is 0, the right operand will not be evaluated. This is often called "short circuiting".

|| is the logical OR operator. It is used for boolean disjunction where any non-zero value is considered to be true. Much like &&, || will short circuit if the left operand resolves to a true.

• 0 || 0 → 0
• 2 && 0 → 1

& is the bitwise AND operator. Each bit in the resulting value is set if and only if each of the corresponding bits in the converted operands is set.

• 0xff & 0xf0 → 0xf0
• 0xfc & 0xf3 → 0xf0
• 0xff & 0x0f → 0x0f

| is the bitwise OR operator. Each bit in the resulting value is set if one of the corresponding bits in the converted operands is set.

• 0xff | 0xf0 → 0xff
• 0xfc | 0xf3 → 0xff
• 0xff | 0x0f → 0xff

^ is the bitwise XOR operator. Each bit in the resulting value is set if and only if exactly one of the corresponding bits in the converted operands is set.

• 0xff ^ 0xf0 → 0x0f
• 0xfc ^ 0xf3 → 0x0f
• 0xff ^ 0x0f → 0xf0

~ is the bitwise NOT operator. Each bit in the resulting value is set if and only if the corresponding bits in the operand is not set.

• ~((char)0xff) → 0x00
• ~((char)0xfc) → 0x03
• ~((char)0x0f) → 0xf0

If I don't explicitly cast the hexadecimal constant to a char, the C compiler will keep it as an int and flip more bits than I wanted to show.

<< is the left bitshift operator. From the standard: "The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with zeros. If E1 has an unsigned type, the value of the result is E1 × 2^E2, wrapped around. If E1 has a signed type and nonnegative value, and E1 × 2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined."

• 0xf << 4 → 0xf0
• 0x80000000 << 1 → 0x00

>> is the right bitshift operator. From the standard: "The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1/2^E2. If E1 has a signed type and a negative value, the resulting value is implementation-defined."

• 0xf0 >> 4 → 0x0f
• 0xf >> 4 → 0x00
• 0x80000000 >> 1 → ??

There are certain edge cases in the C programming language which produce undefined behavior. We'll learn a bit more about it when we get to pointers. For now, think of it as something that is impossible for progammers to know without reading compiler documentation.