The sizeof operator in C is one of those small features that quietly does a lot of heavy lifting. It tells you how much memory (in bytes) a variable, data type, or expression occupies. That’s incredibly useful when you’re working close to the system level, managing memory, or writing portable code. This article focuses on discussing sizeof operator in C.

Table of Contents

---

What is sizeof Operator?

At its core, sizeof is a compile-time operator that returns the size of a data type or variable in bytes.

1. Memory Size: It returns the number of bytes required to store a data type or variable.
2. Compile-Time Evaluation: In most cases, the value is calculated during compilation, not at runtime.
3. Works with Types and Variables: You can use it with both data types (int, float) and variables.

Syntax:
You can use sizeof in two common ways:

sizeof(data_type)
sizeof(variable_name)

Example:

// C program to show sizeof operator
#include stdio.h

// Main function
int main() 
{
    int a = 10;
    
    printf("Size of int: %lu bytes\n", sizeof(int));
    printf("Size of variable a: %lu bytes\n", sizeof(a));
    
    return 0;
}

Output:

Size of int: 4 bytes
Size of variable a: 4 bytes

Using sizeof with Different Data Types

Different data types occupy different amounts of memory depending on the system.

1. Integer Type: sizeof(int) typically returns 4 bytes on most systems.
2. Character Type: sizeof(char) always returns 1 byte.
3. Floating Type: sizeof(float) usually returns 4 bytes.
4. Double Type: sizeof(double) typically returns 8 bytes.

Example:

// C program to show sizeof operator
// with different data types
#include stdio.h

// Main function
int main() 
{
    printf("char: %lu bytes\n", sizeof(char));
    printf("int: %lu bytes\n", sizeof(int));
    printf("float: %lu bytes\n", sizeof(float));
    printf("double: %lu bytes\n", sizeof(double));
    
    return 0;
}

Output:

char: 1 bytes
int: 4 bytes
float: 4 bytes
double: 8 bytes

sizeof with Arrays

Here’s where sizeof becomes really powerful.

1. Total Array Size: It returns the total memory occupied by the entire array.
2. Element Count Calculation: You can calculate number of elements using a simple formula.

Example:

// C program to show sizeof operator
// with arrays
#include stdio.h

// Main function
int main() 
{
    int arr[5] = {1, 2, 3, 4, 5};
    
    int total_size = sizeof(arr);
    int element_size = sizeof(arr[0]);
    int length = total_size / element_size;
    
    printf("Total size: %d bytes\n", total_size);
    printf("Size of one element: %d bytes\n", element_size);
    printf("Number of elements: %d\n", length);
    
    return 0;
}

Output:

Total size: 20 bytes
Size of one element: 4 bytes
Number of elements: 5

sizeof with Structures

When used with structures, sizeof includes padding added by the compiler for memory alignment.

1. Includes Padding: The actual size may be larger than the sum of members.
2. Alignment Matters: Compilers add extra bytes to align data efficiently.

Example:

// C program to show sizeof operator
// with structures
#include stdio.h

struct Example 
{
    char a;
    int b;
};

// Main function
int main() 
{
    printf("Size of structure: %lu bytes\n", sizeof(struct Example));
    return 0;
}

Output:

Size of structure: 8 bytes

sizeof with Pointers

Pointers behave differently compared to arrays.

1. Pointer Size Fixed: The size of a pointer depends on the system (4 bytes in 32-bit, 8 bytes in 64-bit).
2. Not Array Size: sizeof(pointer) gives pointer size, not the size of the memory it points to.

Example:

// C program to show sizeof operator
// with pointers
#include stdio.h

// Main function
int main() 
{
    int *ptr;
    
    printf("Size of pointer: %lu bytes\n", sizeof(ptr));
    
    return 0;
}

Output:

Size of pointer: 8 bytes

Important Rules of sizeof

Here are some rules that can help in using sizeof operator:

1. No Execution of Expression: Expressions inside sizeof are not evaluated.
2. Always Positive: The result is always a non-negative value.
3. Returns Unsigned Type: The return type is size_t (an unsigned integer type).
4. Parentheses Optional (Sometimes): Required for data types, optional for variables.

Common Mistakes

Here are some mistakes that can be avoided while using sizeof operator:

1. Pointer Confusion: Using sizeof(pointer) when you actually need the size of data it points to.
2. Array Decay Issue: Passing arrays to functions turns them into pointers, so sizeof won’t work as expected.
3. Assuming Fixed Sizes: Data type sizes can vary across systems.
4. Ignoring Padding: Structure sizes may be larger due to alignment.
5. Wrong Format Specifier: Using %d instead of %lu or %zu for sizeof.

Conclusion

The sizeof operator looks simple, but it plays a big role in writing efficient and safe C programs. Whether you’re calculating array length, allocating memory, or understanding how data is stored, sizeof gives you clarity.
What this really means is: if you’re working in C and care about memory (and you should), sizeof is something you’ll end up using all the time. Once you get comfortable with it, a lot of low-level concepts start making more sense.

Frequently Asked Questions

1. What does sizeof return in C?

It returns the size in bytes of a data type, variable, or expression.

2. Is sizeof a function?

No, it is an operator, not a function.

3. Does sizeof evaluate expressions?

No, the expression inside sizeof is not executed.

4. Can sizeof be used with arrays?

Yes, it returns the total memory occupied by the array.

5. Why is structure size larger than expected?

Because of padding added for memory alignment.