Foundations — Operators — arithmetic, relational, logical, bitwise, assignment, comma

Before you can trust a single line of C, you need a small toolbox of ideas that the parent note quietly assumes. This page builds each one from nothing — plain words, then a picture, then why the topic needs it. Every symbol is defined before it is used: we start with the two plainest words, then the atoms (bits), then earn each operator symbol one at a time.

0. The two words underneath everything: "value" and "operator"

Before any symbol, pin down the two plainest words the core idea leans on.

Everything below is the machinery that decides which new value comes out. Keep those two words in hand; the whole page is about the values that flow into operators and the values that flow back out.

1. The four plain arithmetic operators + - * /

The most familiar operators are the ones from grade-school arithmetic. They are all binary (two operands) and mean exactly what you expect.

Now that these four symbols are earned, the rest of the page can safely use them in examples.

2. What is a "bit"? (the atoms)

Everything a computer does is built from a bit: a single tiny switch that is either off (0) or on (1). That's the whole vocabulary — two states.

A number like 12 is not stored as the shape "12"; it is stored as a row of switches. Look at the figure: the number is written in base 2, meaning each switch is worth double the one to its right.

Why base 2 and not base 10? Because a wire is easiest to build as "voltage or no voltage" — two states. The whole machine is cheapest when its alphabet has exactly two letters.

3. Powers of two — the place values

The place values 1, 2, 4, 8, 16, ... are the powers of two. We write $2^n$ to mean "multiply 2 by itself $n$ times", where $n$ is a whole number $0,1,2,3,\dots$ (we never need negative $n$ here — a negative exponent like $2^{-1}$ would mean the fraction $\frac{1}{2}$, and switch-columns only ever go up in whole steps). By convention $2^0=1$ (multiplying zero twos leaves you with 1, the starting point).

(The right shift also lives here, but reasoning about it needs the "floor" idea and the sign switch — we build both in the next two sections, then state the shift rule cleanly once we have the tools.)

4. Truncation, floor, and "toward zero"

The parent says integer / truncates toward zero. Three words, three meanings — let's earn them on a number line.

For positive numbers truncate and floor agree (3.5 → 3 either way). They only differ for negatives — which is exactly why the parent's -7/2 = -3 example needs this distinction.

5. Sign: how a switch-row holds a negative number

The parent writes -7 / 2 and -7 % 2. But if a byte is just switches worth $1,2,4,8,\dots$, how is anything negative? The trick is called two's complement: the leftmost switch is given a negative place value.

How do you actually build $-7$ from $+7$? The recipe is invert every bit, then add 1 (here "invert" means flip every switch, the ~ operation earned in section 9):

• Start with $+7=$ 0000 0111.
• Invert every switch: 1111 1000.
• Add 1: 1111 1001.

Check that this really is $-7$ using the negative top-bit: $-128+64+32+16+8+1=-7$. ✓

Why invert-and-add-1 works, in one sentence: inverting turns $x$ into "(all-ones) $-x$", and all-ones is $-1$ in this scheme, so inverting gives $-1-x$; adding 1 lands you on $-x$. The full story lives in Two's Complement Representation; here you only need the picture: the top switch is a "sign switch", and negatives are made by invert-and-add-1.

6. Now the shift rule (needs powers of two + floor + sign)

The two shift operators slide a switch-row sideways.

With powers of two, floor, and the sign switch in hand, we can state what those slides compute.

7. Types: int vs double

A type is a label on a value saying what kind of thing it is and how it's stored.

The deep story of how one becomes the other is Data Types and Type Promotion; for the parent you only need one rule, shown below.

8. The two integer operators / and %

Now we can define what / does for whole numbers and introduce its partner %.

9. The four bitwise combiners & | ^ ~

Section 2 showed a number is a row of switches. These four operators work column by column on those switches. (~ is the "invert" tool we borrowed early in section 5 — here is its full definition.)

10. Arity — how many operands

11. Comparing values: relational & equality operators

These six operators ask a yes/no question about two values and hand back a clean answer.

12. Combining yes/no answers: logical operators

Once you can produce true/false values, you combine them with three logical operators.

13. Truth in C: 0, nonzero, and "true"

Classic C has no dedicated Boolean type. Instead:

14. Precedence & associativity — the seating order

When several operators sit in one expression, precedence decides who fires first, and associativity breaks ties between equals.

The prerequisite map

The diagram below is a dependency chart: read an arrow X --> Y as "you need X before Y makes sense." Follow any path and you'll see the order this page built things in — bits at the top feed everything, and every strand eventually flows down into the Operators topic itself.

Equipment checklist

Self-test: cover the right side and answer out loud.