Learn sizeof in C with simple examples. Understand usage, return type, format specifier, array size, strlen vs sizeof, and avoid common mistakes easily.
If you have ever wondered how big a data type, variable, or structure is in memory, you’ve already touched the topic of sizeof in C. It’s one of those things every C programmer uses, yet many misunderstand. So today, let’s sit down, simplify everything, and walk through sizeof from the basics to the tricky parts that show up in interviews.
If you’re learning C programming and want to strengthen your fundamentals before practicing Structures and Unions Interview Questions, you should explore this detailed beginner-friendly guide on structures: Structures in C – Complete Guide
It explains structure syntax, memory layout, padding, nesting, and real-world examples in a very simple way. Reading this will give you a strong foundation before jumping into advanced interview questions.
What is sizeof in C?
The sizeof operator tells you how much memory something takes in bytes.
It works for:
- data types
- variables
- expressions
- pointers
- arrays
- structures
- unions
- function return types
- and more
Example:
printf("%zu", sizeof(int));This prints the number of bytes needed to store an int on your system.
Why sizeof exists
C runs close to hardware. You often need to know how much memory something consumes to:
- allocate memory safely
- handle arrays
- write low-level drivers
- work with network packets
- optimize memory usage
Without sizeof, developers would guess memory sizes. And guessing in C is dangerous.
How to use sizeof in C
The syntax is simple.
sizeof(type)
sizeof variable
sizeof expression
Examples:
sizeof(int)
sizeof x
sizeof(x+10)
All are valid.
Syntax and examples
int a = 10;
printf("%zu", sizeof(a)); // sizeof variable
printf("%zu", sizeof(int)); // sizeof type
printf("%zu", sizeof(a+1)); // sizeof expression
What does sizeof in C return?
sizeof returns the size in bytes.
If int is 4 bytes:
sizeof(int) → 4
If a structure is 16 bytes:
sizeof(struct Example) → 16
Return type of sizeof in C
The return type of sizeof in C is:
size_t
size_t is an unsigned integer type used for sizes.
It’s defined in
Is sizeof a function in C?
No.
sizeof is an operator, not a function.
This is important because:
- it is evaluated at compile time (for most cases)
- it does not cause side effects
- it doesn’t evaluate expressions fully
Example:
sizeof(a++);
a will NOT increment.
What library is sizeof in C?
No library.sizeof is built directly into the compiler.
You do not need to include any header.
Format specifier for sizeof in C
Since sizeof returns a size_t, you print it using:
%zu
Example:
printf("%zu", sizeof(int));
Many programmers mistakenly use %d, but %zu is correct.
sizeof with basic data types
This depends on architecture, compiler, alignment, and ABI.
Example on a 64-bit machine:
sizeof(char) → 1
sizeof(int) → 4
sizeof(float) → 4
sizeof(double)→ 8
sizeof(long) → 8
sizeof with variables vs constants
int x = 10;
sizeof x; // OK
sizeof(10); // OK: integer constant is type int
sizeof with arrays
This is one of the most important uses.
int arr[10];
sizeof(arr); // 40 bytes (if int=4)
General rule:
sizeof(array) = element_size × number_of_elements
But note:
sizeof(arr) != sizeof pointer
sizeof with pointers
int *p;
sizeof(p); // size of pointer (8 bytes on 64-bit)
Pointers always have the same size regardless of what they point to.
sizeof with strings
Strings are tricky.
Let’s compare:
Case 1: String literal array
char s[] = "Hello";
sizeof(s);
"Hello" is 5 chars + null char → 6 bytes.
Case 2: Pointer to string literal
char *p = "Hello";
sizeof(p);
This returns pointer size (8 bytes on 64-bit), NOT 6.
strlen vs sizeof in C
One of the most asked questions.
strlen
- counts characters in a string
- stops at NULL
'\0' - works at run time
sizeof
- gives total memory size
- works at compile time
- includes
'\0'in string arrays
difference between strlen and sizeof in C
Let’s compare them clearly:
| Expression | Result | Why |
|---|---|---|
sizeof("Hello") | 6 | includes null terminator |
strlen("Hello") | 5 | counts until null but not including it |
Example:
char s[] = "Hello";
printf("%zu", sizeof(s)); // 6
printf("%zu", strlen(s)); // 5
sizeof with functions
You cannot do:
sizeof(func)
But you can do:
sizeof(func()) // returns size of return type
Example:
int fun();
sizeof(fun()); // size of int
sizeof with structures
sizeof accounts for:
- actual member sizes
- padding for alignment
Example:
struct A {
char a; // 1 byte
int b; // 4 bytes
};
sizeof(struct A);
Most compilers will align the struct → 8 bytes.
sizeof with unions
Unions store all members in the same memory location.
Rule:
sizeof(union) = size of largest member
Example:
union B {
int x; // 4 bytes
double y; // 8 bytes
};
sizeof(union B); // 8
sizeof with enums
Enums are generally the size of an int:
sizeof(enum Example) → 4
sizeof with typedef
typedef does not affect memory layout.
Example:
typedef int myInt;
sizeof(myInt) = sizeof(int);
sizeof and operator precedence
Parentheses are optional for variables:
sizeof x; // OK
But required for types:
sizeof(int); // parentheses required
sizeof and expressions
sizeof does not evaluate the expression inside.
Example:
int x = 10;
sizeof(x++); // x does not increment
The compiler only checks the type of x++.
sizeof and macros
Common macro to find array length:
#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
implementation of sizeof in C (internal view)
sizeof is implemented by the compiler:
- It does not generate assembly instructions.
- It is evaluated during compilation.
- It uses type information from symbol tables.
When applied to variable length arrays, compile-time evaluation is not possible; then sizeof becomes runtime.
Simple Way to “Implement sizeof” in C (Conceptual Trick)
In C, you cannot really implement sizeof because it is a compiler operator.
But you can simulate it for known types using a simple pointer trick.
#define my_sizeof(type) ((char *)(&type + 1) - (char *)(&type))
How this works?
( &type )→ address of the variable( &type + 1 )→ address of next element after the variable- Casting both to
char*means pointer moves 1 byte at a time - Subtracting addresses gives number of bytes occupied
Example Usage
#include
#define my_sizeof(type) ((char *)(&type + 1) - (char *)(&type))
int main() {
int x;
double d;
char c;
printf("Size of int: %ld\n", my_sizeof(x));
printf("Size of double: %ld\n", my_sizeof(d));
printf("Size of char: %ld\n", my_sizeof(c));
return 0;
}
Output (example)
Size of int: 4
Size of double: 8
Size of char: 1
Limitations
- Works only with variables, not types.
- Cannot handle:
my_sizeof(int)(because no variable)- structure padding details with just a type
- Not equivalent to real
sizeofoperator.
Bonus Version: For Types Using a Dummy Variable
You can also simulate for types by creating a dummy variable.
#define my_sizeof_type(type) ((size_t)(&((type*)0)[1]) - (size_t)(&((type*)0)[0]))
Usage:
printf("%zu", my_sizeof_type(int));
printf("%zu", my_sizeof_type(double));
This works because:
(type*)0→ NULL pointer to type((type*)0)[1]→ next element of array- Subtraction gives size of type
- Real
sizeofis done by the compiler, not in C code - Above macros simulate the logic using pointer arithmetic
- They are ONLY for learning purpose
sizeof portability issues
Avoid assuming specific sizes like:
int = 4 bytes
long = 4 bytes
char = 1 byte
Because:
- sizes change by architecture
- padding rules differ
- compilers treat alignment differently
Always use sizeof instead of hardcoding sizes.
Common pitfalls and mistakes
Mistake 1: Using sizeof on pointer instead of array
int *p = malloc(10 * sizeof(int));
sizeof(p); // wrong: gives pointer size
Mistake 2: Using %d instead of %zu for printing sizeof
Mistake 3: Using strlen to measure binary data
strlen stops at '\0', sizeof doesn’t.
Interview Questions (Beginner to Advanced)
- What is sizeof in C?
- Is sizeof a function or operator?
- What is the return type of sizeof?
- Does sizeof evaluate expressions?
- How do you print sizeof results?
- What is the format specifier for sizeof in C?
- How to use sizeof with arrays?
- Why sizeof pointer != sizeof array?
- strlen vs sizeof in C — explain with examples.
- difference between strlen and sizeof in C
- What does sizeof in C return for a struct?
- How does padding affect struct size?
- sizeof with string literal vs char pointer
- sizeof with union — why max member?
- Can sizeof be overloaded?
- Can sizeof work on functions?
- How does compiler implement sizeof?
- sizeof for VLA (Variable Length Arrays)
- Why sizeof returns size_t?
- What library is sizeof in C?
These are commonly asked in interviews for freshers, embedded developers, and experienced programmers.
Summary
Here’s what you should remember:
- sizeof in C is a compile-time operator.
- It returns size in bytes of any type or object.
- The return type is
size_t. - Use %zu to print it.
sizeof(array)gives full array size;sizeof(pointer)does not.strlencounts characters;sizeofcounts memory.- sizeof never executes expressions inside it.
- Struct size includes padding.
- Union size is maximum member size.
- sizeof is defined by the compiler, not in a library.
FAQ
1. What is sizeof in C used for?
It tells you how much memory a data type or variable takes in bytes. It’s mostly used for memory allocation and array calculations.
2. Is sizeof a function or an operator?
It is an operator, not a function.
3. How do I print sizeof in C?
Use the correct format specifier:
printf("%zu", sizeof(int));
4. What is the return type of sizeof in C?
size_t, which is an unsigned type used for sizes.
5. How to use sizeof in C with arrays?
int arr[10];
printf("%zu", sizeof(arr)); // 40 bytes if int = 4
6. What does sizeof return for pointers?
Always the size of the pointer itself, not the memory it points to.
7. What library defines sizeof?
None. sizeof is built into the compiler.
8. difference between strlen and sizeof in C?
strlen counts characters; sizeof counts memory.
9. How to use sizeof safely in dynamic memory?
Always use:
malloc(n * sizeof(*ptr));
10. Can sizeof change between systems?
Yes, sizes of int, long, pointers vary by architecture. Always use sizeof instead of hardcoding size values.
Mr. Raj Kumar is a highly experienced Technical Content Engineer with 7 years of dedicated expertise in the intricate field of embedded systems. At Embedded Prep, Raj is at the forefront of creating and curating high-quality technical content designed to educate and empower aspiring and seasoned professionals in the embedded domain.
Throughout his career, Raj has honed a unique skill set that bridges the gap between deep technical understanding and effective communication. His work encompasses a wide range of educational materials, including in-depth tutorials, practical guides, course modules, and insightful articles focused on embedded hardware and software solutions. He possesses a strong grasp of embedded architectures, microcontrollers, real-time operating systems (RTOS), firmware development, and various communication protocols relevant to the embedded industry.
Raj is adept at collaborating closely with subject matter experts, engineers, and instructional designers to ensure the accuracy, completeness, and pedagogical effectiveness of the content. His meticulous attention to detail and commitment to clarity are instrumental in transforming complex embedded concepts into easily digestible and engaging learning experiences. At Embedded Prep, he plays a crucial role in building a robust knowledge base that helps learners master the complexities of embedded technologies.
