Why `sizeof(x++)` Does Not Increment `x` in C

By the end of this page, you will understand that sizeof usually determines the size of a type without evaluating its expression operand. That is why sizeof(x++) returns the size of int, but the side effect of x++ never happens, so x stays 5. You will also learn the important exception involving variable length arrays.

In C, sizeof is an operator that tells you how many bytes a type or object occupies.

For example:

sizeof(int)
sizeof x
sizeof(x)

all ask for a size in bytes.

The key idea is this:

• sizeof usually does not evaluate the expression you put inside it.
• It only uses that expression to determine its type.
• Since the expression is not executed, any side effects inside it do not happen.

That is exactly what happens here:

sizeof(x++)

x++ is a post-increment expression. Normally, evaluating it would:

1. produce the current value of x
2. increment x afterward

But inside sizeof, the expression is typically not evaluated at all. C only checks the type of x++, which is int, and returns sizeof(int).

Think of sizeof as asking a librarian:

"How big is a book of this category?"

The librarian does not need to read the whole book to answer. They just look at the label or classification.

In the same way, sizeof(x++) does not "run" the increment. It simply looks at the expression and says:

• x++ has type int
• an int is 4 bytes here

So sizeof answers 4 and never performs the ++.

Another way to think about it:

• x++ is an action with a side effect
• sizeof(...) usually asks only for type/size information
• if no action is executed, no side effect occurs

Core syntax

sizeof(type)
sizeof expression

Examples:

sizeof(int)
sizeof(double)
sizeof x
sizeof(x + 1)

Example 1: Simple variable

#include <stdio.h>

int main(void) {
    int x = 5;
    printf("%zu\n", sizeof(x));
    return 0;
}

This prints the number of bytes used by x's type, which is usually the size of int.

Example 2: Expression inside sizeof

#include 

  {
     x = ;
    (, (x + ));
    (, x);
     ;
}

Consider this program:

#include <stdio.h>

int main(void) {
    int x = 5;
    size_t s = sizeof(x++);
    printf("size = %zu, x = %d\n", s, x);
    return 0;
}

Step-by-step

1. int x = 5;

A variable x is created and initialized to 5.

2. size_t s = sizeof(x++);

C looks at x++ only to determine its type.

• x is an int
• x++ also has type int
• sizeof(int) is usually 4

So gets the value .

Understanding this behavior is useful in several practical situations.

1. Writing safe macros

C codebases often use macros that depend on sizeof:

#define ARRAY_BYTES(arr) (sizeof(arr))
#define ARRAY_LEN(arr) (sizeof(arr) / sizeof((arr)[0]))

These work because sizeof can inspect types and sizes without evaluating expressions in the usual case.

2. Allocating memory

Developers often write:

int *p = malloc(10 * sizeof(*p));

This is useful because sizeof(*p) gives the size of the pointed-to type without dereferencing memory in the runtime sense.

3. Avoiding side-effect confusion

If you accidentally write code like this:

sizeof(i++)

expecting i to change, your program logic will be wrong. Understanding the rule helps you avoid subtle bugs.

4. Reading unfamiliar C code

In real projects, you will often see expressions placed inside for type-based sizing. Knowing that they are usually not evaluated helps you read code correctly.

In real C projects, sizeof is commonly used in patterns like these.

Type-safe allocation

int *arr = malloc(count * sizeof(*arr));

Why developers like this:

• it avoids repeating the type name
• if the variable type changes later, the sizeof part stays correct

Struct sizing

struct User *u = malloc(sizeof(*u));

This is clearer and less error-prone than manually writing the struct type again.

Array length macros

#define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))

This works for actual arrays, not pointers.

Guarding against logic mistakes

Experienced developers avoid writing expressions with side effects inside sizeof, even though they know those expressions are usually not evaluated. For example, they prefer not to write:

(x++)

1. Expecting side effects to happen

Broken expectation:

int x = 5;
size_t s = sizeof(x++);
printf("%d\n", x);  // still 5, not 6

How to avoid it

Do not place increments, decrements, assignments, or function calls inside sizeof if you expect them to run.

2. Using the wrong printf format specifier

Broken code:

printf("%d\n", sizeof(x));

Why it is a problem:

• sizeof returns size_t
• %d is for int

Better:

printf("%zu\n", sizeof(x));

3. Confusing arrays and pointers

Broken assumption:

sizeof vs normal evaluation

sizeof on a type vs an expression

Quick rules for sizeof

• sizeof returns the size in bytes.
• The result type is size_t.
• Use %zu to print a sizeof result.
• sizeof usually does not evaluate its expression operand.
• Side effects inside sizeof usually do not happen.
• Exception: variable length arrays can require runtime evaluation.

Common forms

sizeof(int)
sizeof x
sizeof(x)
sizeof(x + 1)

Important example

int x = 5;
size_t s = sizeof(x++);

After this:

x == 5

because x++ was not evaluated.

Why does sizeof(x++) not change x in C?

Because sizeof usually does not evaluate its operand expression. It only determines the expression's type and returns that type's size.

Does sizeof ever evaluate its operand?

Usually no. The important exception is when variable length arrays are involved, because their size may need runtime evaluation.

What does sizeof(x++) actually return?

It returns the size in bytes of the type of x++. If x is an int, that is typically the same as sizeof(int).

Why did my program print 4 and 5?

4 is the typical size of int on your system, and 5 remains unchanged because x++ was not executed.

Should I use %d to print sizeof results?

No. The correct format specifier is because returns .

• post-increment operator - Related because x++ normally has a side effect, which helps explain why sizeof(x++) is surprising.
• operator precedence - Useful for understanding how expressions like sizeof x and sizeof(x++) are parsed.
• size_t - Important because it is the return type of sizeof.
• printf format specifiers - Related because sizeof results should be printed with %zu.
• arrays and pointers in C - Important because sizeof behaves very differently with arrays and pointers.
• variable length arrays - Related because they are the main exception where sizeof may involve runtime evaluation.
• compile-time vs runtime - Helps explain why sizeof often behaves like a compile-time size query.
• memory allocation with malloc - Commonly uses sizeof in real programs.