What type of value does sizeof return

The sizeof operator, returns the size of an expression, or of an object type in C. An expression is for example 1 + 2, an object is any region of memory, and a type is for example int. The value returned by the sizeof operator, is of type size_t, and its unit is byte.

Table of Contents Show

sizeof and structures
sizeof and unions
sizeof and arrays
sizeof and pointers
sizeof and other object types
sizeof and expressions
sizeof cannot be applied?

sizeof( Type ) /* When using sizeof with an object type such as an int , the parenthesis () must be used .*/ sizeof expression sizeof( expression ) /* When the sizeof operator is used with an expression, the parenthesis () can or cannot be used .*/

size_t is an unsigned integer type, which is defined in the stddef.h header. It can hold any value returned by the sizeof operator, and has a min value of 0, and a max value of the largest value, that can be returned by the sizeof operator. size_t can for example be defined as:

typedef unsigned long size_t;

The sizeof operator returns 1, meaning 1 byte, when used with the char, unsigned char, or signed char types.

#include <stdio.h> int main( int argc, char * argv [ ] ){ printf( "sizeof( char ) is: %lu\n", sizeof( char ) ); /*output: sizeof( char ) is: 1 */ return 0;}

The number of bits in a char, is defined in the limits.h header, using the macro CHAR_BIT.

#define CHAR_BIT 8

The following example illustrates, how to get the number of bits for other types.

#include <stdio.h> /* include the stdio.h header, in order to use printf, to print formatted strings .*/ #include <limits.h> /* include the limits.h header, to use CHAR_BIT, which defines the number of bits, that the char type can have .*/ int main( int argc, char * argv[ ] ) { printf( "sizeof( int ) is: %lu bytes\n", sizeof( int )); /* output: sizeof( int ) is: 4 bytes .*/ printf( "size of int in bits is: %lu bits\n", sizeof( int ) * CHAR_BIT ); /* output: size of int in bits is: 32 bits .*/ return 0;}

sizeof and structures

When sizeof is used with a structure, it returns the size of the elements in this structure, with any padding. Padding will happen, when the size of the structure is not a multiple of the size of the largest element in this structure.

A structure is padded with bits, that don’t have any specific value, till it has a size which is a multiple of the largest element in this structure. Padding happens to have faster access to the structure elements, and because sometimes some cpu architecture don’t support access to non aligned memory.

#include <stdio.h> /* include the stdio header to use the printf function .*/ struct aPaddedStruct{ char aChar; // aChar has a size of 1 int anInt; /* anInt has a size of 4 bytes .*/ }; /* The size of aPaddedStruct is 8 instead of 5, since the size of the largest element in this struct is 4 bytes .*/ int main( int argc , char * argv[ ] ){ printf( "sizeof( struct aPaddedStruct ) is: %lu", sizeof( struct aPaddedStruct )); // sizeof( struct aPaddedStruct ) is: 8 return 0; }

If the last element of a structure is an array, which size is not defined, then sizeof will return the size of the structure, without the array size.

#include<stdio.h> /* include the stdio header, to use the printf function .*/ struct aStruct{ short aShort; /* size of short is 2 bytes .*/ char aCharOne; // size of char is 1 char aCharTwo; // size of char is 1 int anIntArray[ ]; /* anIntArray doesn't have a size, because it does not define the number of elements it has.*/ }; // size of aStruct is 4 int main( int argc, char *argv[ ] ){ printf( "sizeof( aStruct ) is: %lu", sizeof( struct aStruct )); /*output : sizeof( aStruct ) is: 4 */ return 0; }

sizeof and unions

sizeof returns the size of the largest element in a union.

#include <stdio.h> /* include the stdio header, to use the printf function .*/ union aUnion{ char aChar; // size of char is 1 int anInt; // size of int is 4 long double aLongDouble; /*size of long double is 16 .*/ }; /* union aUnion will have the size of its largest element, it is aLongDouble, which is a long double, as such it has a size of 16 .*/ int main( int argc, char * argv[ ] ){ printf( "sizeof( union aUnion ) is: %lu" ,sizeof( union aUnion )); /* output: sizeof( union aUnion ) is: 16 .*/ return 0;}

A compiler might add padding to a union, so that its size, will be a multiple of the size of the largest element, in this union. This is used to allow faster access, or because some cpu architecture, don’t allow access to non aligned boundaries.

#include <stdio.h> /* include the stdio header, to use the printf function .*/ struct _aStruct{ int anIntOne; // size of an int is 4 short aShort; // size of a short is 2 int anIntTwo; /* size of an int is 4 .*/ }; /* The size of _aStruct is 12, since it is padded to the size of its largest element, which is an int .*/ union aUnion{ struct _aStruct aStruct; // size of struct _aStruct is 12 long aLong; /* size of long is 8 .*/ }; /* The size of the largest element in this union is long. The union is padded to the size of its largest element, hence it has a size of 16 .*/ int main( int argc, char * argv[ ] ){ printf( "The size of aUnion is: %lu\n", sizeof( union aUnion )); /*output: the size of aUnion is: 16 */ return 0;}

sizeof and arrays

When using sizeof with an array, it will return the size of all the elements in the array.

#include <stdio.h> /* include the stdio header, to use the printf function .*/ int main( int argc, char * argv[ ] ){ int anIntArray[ 22 ]; /* anIntArray has a size of the size of the int type, multiplied by 22. so it has a size of 4 * 22 = 88 bytes .*/ printf( "sizeof( anIntArray ) is: %lu\n" , sizeof( anIntArray )); // sizeof( anIntArray ) is: 88 char aCharArray[ 3 ]; /* aCharArray has a size of the size of the char type, multiplied by 3 . so it has a size of 1 * 3 = 3 bytes .*/ printf( "sizeof( aCharArray ) is: %lu\n" , sizeof( aCharArray )); // sizeof( aCharArray ) is: 3 return 0;}

sizeof can be used to calculate the number of elements in an array, by dividing the size of the array, by the size of an element in the array.

#include <stdio.h> /* include the stdio header, to use the printf function .*/ int main( int argc, char * argv[ ] ){ short aShortArray[ 4 ]; /* aShortArray has a size of the size of the short type, multiplied by 4, so it has a size of 2 * 4 = 8 .*/ printf( "Number of elements in the array is: %lu\n", sizeof( aShortArray ) / sizeof( aShortArray[ 0 ] )); /* sizeof( aShortArray ) is equal to sizeof( short ) * 4 sizeof( aShortArray[ 0 ] ) is equal to sizeof( short ) hence sizeof( aShortArray ) / sizeof( aShortArray[ 0 ] ) = number of elements in the array output: Number of elements in the array is: 4 .*/ return 0;}

sizeof and pointers

A pointer is simply an address which is stored in memory, as such it has a size. The sizeof operator, can be used to get the size of a pointer. There is no defined size of a pointer in C, it is defined by the implementation, usually on a 32 bits machine, a pointer has a size of 32 bits, and on a 64 bits machine, a pointer has a size of 64 bits.

#include <stdio.h> /* include the stdio header, to use the printf function .*/ int main(int argc, char * argv[ ]){ printf("sizeof( void * ) is %lu\n", sizeof (void * )); // sizeof( void * ) is 8 printf( "sizeof( char * ) is %lu\n", sizeof( char * )); // sizeof( char * ) is 8 return 0;}

sizeof and other object types

An object is just a memory region, so it has an allocated size. The object types in C are:

integer types, such as int, short, enum…
floating types, such as float, double, long double.
structures.
unions.
arrays.
pointers.
atomic types.

#include <stdio.h> /* include the stdio header, to use the printf function .*/ #include <stdatomic.h> /* include the stdatomic header, to access the atomic types .*/ enum Binary{ zero, one }; /* define the enum Binary, an enum is an integer of the type int .*/ struct Boolean{ char _cBool; unsigned char _iBool; } true = {'T', 1}, false = {'F', 0}; /* define a Boolean structure. the Boolean structure defines that a boolean, has a char and an int representation. Two variables were initialized from this structure, true and false .*/ union BooleanOrBinary { enum Binary binary; struct Boolean boolean;}; /* Define a union BooleanOrBinary, to store a boolean value , as either of type struct Boolean or as of type enum Binary .*/ /* Print the sizeof object types on a given machine. The sizeof a char is always 1. The sizeof object types are a multiple of the sizeof a char. The size of objects types might vary from one machine to another .*/ int main( ){ printf( "sizeof( char ) is : %lu byte\n", sizeof( char )); // sizeof( char ) is: 1 byte printf( "sizeof( short ) is : %lu byte\n", sizeof( short )); // sizeof( short ) is: 2 byte printf( "sizeof( int ) is: %lu byte\n", sizeof( int )); // sizeof( int ) is: 4 byte printf("sizeof( long int ) is: %lu byte\n", sizeof( long int )); // sizeof( long int ) is: 8 byte printf( "sizeof( long long int ) is: %lu byte\n", sizeof( long long int )); // sizeof(long long int) is : 8 byte printf( "sizeof( float ) is: %lu byte\n", sizeof( float )); // sizeof( float ) is: 4 byte printf( "sizeof( double ) is: %lu byte\n", sizeof( double )); // sizeof( double ) is: 8 byte printf( "sizeof( long double ) is: %lu byte\n", sizeof( long double )); // sizeof( long double ) is: 16 byte printf( "sizeof( enum binary ) is: %lu byte\n", sizeof( enum Binary )); // sizeof( enum binary ) is: 4 byte printf( "sizeof( struct Boolean ) is : %lu byte\n", sizeof( struct Boolean )); // sizeof( struct Boolean ) is: 2 byte printf( "sizeof( union BooleanOrBinary ) is: %lu byte\n", sizeof( union BooleanOrBinary )); // sizeof( union BooleanOrBinary ) is: 4 byte printf( "sizeof( void * ) is %lu byte\n", sizeof( void * )); // sizeof( void * ) is 8 byte printf( "sizeof( int[ 1 ] ) is: %lu byte\n", sizeof( int[ 1 ] )); // sizeof( int[ 1 ] ) is: 4 byte printf( "sizeof( atomic_int_fast32_t ) is: %lu byte\n", sizeof( atomic_int_fast32_t )); // sizeof( atomic_int_fast32_t ) is: 4 byte return 0; }

sizeof and expressions

sizeof expression sizeof( expression )

An expression is simply a combination of operands and operators, whatever these operand or operators are. When using the sizeof operator with an expression, the parenthesis () can be used or skipped .

#include <stdio.h> /* include the stdio header, to use the printf function .*/ int sum( int x, int y ){ /* return the sum of x and y */ return x + y; } int main( int argc, char * argv[ ] ){ int anInt = 1; printf( "sizeof anInt is: %lu \n", sizeof anInt ); // sizeof anInt is: 4 double aDouble = 3.0; printf( "sizeof aDouble is: %lu \n", sizeof aDouble ); // sizeof aDouble is: 8 printf( "sizeof( aDouble + anInt ) is: %lu \n", sizeof( aDouble + anInt )); // sizeof( aDouble + anInt ) is: 8 printf( "sizeof( 3.0f + 1 ) is: %lu \n", sizeof( 3.0f + 1 )); /* 3.0f is a float 3.0f + 1 = 4.0f 4.0f is a float sizeof( float ) is 4 Output: sizeof (3.0 + 1) is: 4 .*/ printf( "sizeof sum( 1, 5 ) is: %lu \n", sizeof sum( 1, 5 )); // sizeof sum( 1, 5 ) is: 4 printf( "sizeof 100 is: %lu \n", sizeof 100 ); // sizeof 100 is: 4 return 0;}

sizeof cannot be applied?

The sizeof operator, cannot be applied to a non object type, such as a function, or to an incomplete type. An incomplete type, is a type which is declared but not yet defined, or a type which doesn’t have a size, such as the void type.

struct incompleteTypeStruct; /* struct incompleteTypeStruct is declared but is not yet defined , as such it is an incomplete type .*/ enum incompleteTypeEnum; /* enum incompleteTypeEnum is declared but is not yet defined, as such it is an incomplete type .*/ int anIntarray[ ]; /* anIntarray size is not defined, as such it is an incomplete type .*/ int main( int argc, char * argv[ ] ){ sizeof( struct incompleteTypeStruct ); sizeof( enum incompleteTypeEnum ); sizeof( anIntarray ); sizeof( void ); /* These statements will cause an error, since they are trying to get the size of incomplete types .*/ return 0;}