Unary Operators in C: Working With Single Operands

What Is a Unary Operator?

Aunary operatoroperates on exactlyone operand:

Compare with the operator family tree:

C has six everyday unary operators. Let's meet each one.

1. Unary Minus (-): The Sign Flipper

Place-before a single value and it negates it:

Don't confuse it with subtraction:a - bisbinaryminus (two operands);-aisunaryminus (one operand, sign flipped). Same symbol, different job — C figures out which you meant from context.

2. Unary Plus (+): The Operator That Does (Almost) Nothing

Perfectly legal, mostly decorative:

Unary plus exists mainly for symmetry with unary minus. Behind the scenes it can trigger integer promotion (acharbecomes anint), but in daily code you'll rarely write it. Know it exists; move on.

3. Logical NOT (!): The Truth Inverter

One!flips true to false and false to true — the same rule from : zero becomes 1, non-zero becomes 0:

if (!flag)reading as "if NOT flag" is one of the most common idioms in real C code. The!!double-flip is a sneaky way to crush any value to exactly 0 or 1.

4. Bitwise NOT (~): The Bit Flipper

One operand, and every single bit gets inverted:

On signed values the famous rule applies:~xequals-x - 1(two's complement storage). So~5is-6. This operator is the engine behind clearing bits —flags & ~MASK

5. Increment and Decrement (++ and --): The Famous Pair

The operators so iconic a language was named after them:

Both are unary (one operand), and both come in two flavors with a timing difference:

Post means "use the value, change it after." Pre means "change first, then use." Standing alone (count++;), both do the same thing — the difference only bites inside expressions. This pair gets the full treatment.

6. sizeof: The Size Detective

sizeoflooks like a function but is actually acompile-time operator— it reports how many bytes a type or variable occupies:

That last line powers the classic array-length formula you'll use forever:

Becausesizeofruns at compile time, it costs nothing at runtime — a genuinely free safety tool.

7. The Pointer Gateways: & and *

Two unary operators open the door to C's superpower:

• &x— "give me theaddress ofx" (unary — one operand)
• *p— "give me thevalue atthat address" (unary — one operand)

Again, context distinguishes these from their binary cousins:a & bis bitwise AND,a * bis multiplication — but&xand*pare pointer operators. When you're ready takes you deep.

One Operand, One Table: The Complete Reference

A Complete Working Example

#include <stdio.h>
int main() {
    int temperature = -8;
    int isSunny = 0;
    int counter = 0;
    // unary minus flips the sign
    printf("Absolute temp: %d\n", -temperature);
    // 8
    // logical NOT flips the truth
    if (!isSunny) {
        printf("No sun today.\n");
    }
    // ++ counts sightings
    counter++;
    counter++;
    printf("Cloud sightings: %d\n", counter);
    // 2
    // sizeof measures the toolbox
    printf("int size here: %zu bytes\n", sizeof(temperature));
    // & and * play pointer tag
    int *p = &counter;
    *p += 10;
    // modify through pointer
    printf("Counter now: %d\n", counter);
    // 12
    return 0;
}

Output:

Absolute temp: 8
No sun today.
Cloud sightings: 2
int size here: 4 bytes
Counter now: 12

Six unary operators, one tiny program — each doing its solo act.