Skip to content
Related Articles
Open in App
Not now

Related Articles

What is the size_t data type in C?

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 02 Feb, 2023
Improve Article
Save Article

size_t is an unsigned integral data type which is defined in various header files such as: 
 

C




<stddef.h>, <stdio.h>, <stdlib.h>, <string.h>, <time.h>, <wchar.h>


It’s a type which is used to represent the size of objects in bytes and is therefore used as the return type by the sizeof operator. It is guaranteed to be big enough to contain the size of the biggest object the host system can handle. Basically the maximum permissible size is dependent on the compiler; if the compiler is 32 bit then it is simply a typedef(i.e., alias) for unsigned int but if the compiler is 64 bit then it would be a typedef for unsigned long long. The size_t data type is never negative.
Therefore many C library functions like malloc, memcpy and strlen declare their arguments and return type as size_t. For instance, 
 

C




// Declaration of various standard library functions.
 
// Here argument of 'n' refers to maximum blocks that can be
// allocated which is guaranteed to be non-negative.
void *malloc(size_t n);
 
// While copying 'n' bytes from 's2' to 's1'
// n must be non-negative integer.
void *memcpy(void *s1, void const *s2, size_t n);
 
// strlen() uses size_t because the length of any string
// will always be at least 0.
size_t strlen(char const *s);


size_t or any unsigned type might be seen used as loop variable as loop variables are typically greater than or equal to 0.
Note: When we use a size_t object, we have to make sure that in all the contexts it is used, including arithmetic, we want only non-negative values. For instance, the following program would definitely give the unexpected result: 
 

Example no 1

C




// C program to demonstrate that size_t or
// any unsigned int type should be used
// carefully when used in a loop.
#include<stdio.h>
 
#define N 10
 
int main()
{
    int a[N];
 
    // This is fine.
    for (size_t n = 0; n < N; ++n) {
        a[n] = n;
    }
         
    // But reverse cycles are tricky for unsigned
    // types as they can lead to infinite loops.
    for (size_t n = N-1; n >= 0; --n)
        printf("%d ", a[n]);
}


Output
Infinite loop and then segmentation fault

 
 Example no 2

  • The size_t data type in C is an unsigned integer type used to represent the size of objects in bytes. It is defined in the stddef.h header and is commonly used to represent the size of arrays, memory blocks, and strings.
  • Here is an example program that demonstrates the use of size_t:

C




#include <stddef.h>
#include <stdio.h>
 
int main() {
  int array[5] = {1, 2, 3, 4, 5};
  size_t size = sizeof(array);
 
  printf("The size of the array is: %lu\n", size);
 
  return 0;
}


  • in this program, size_t is used to store the size of the array in bytes. 
  • The sizeof operator is used to determine the size of the array, which is then stored in the size variable of type size_t. The %lu format specifier is used to print the value of size_t, which is an unsigned long integer. 
  • The program outputs “The size of the array is: 20”, which is the number of bytes occupied by the array (5 elements * 4 bytes per element).

Advantages of using size_t in C programming:

  • Portability: The size_t data type is defined in the stddef.h header, which is part of the C standard library. By using size_t, you can ensure that your code is portable across different platforms and compilers.
  • Unsigned: size_t is an unsigned integer type, which means it can represent sizes up to the maximum size of unsigned integers. This is useful when dealing with arrays and memory blocks, as sizes can never be negative.
  • Performance: size_t is usually implemented as a fast and efficient integer type, and using it can result in better performance than using other integer types.
  • Clear intent: Using size_t makes it clear to the reader of your code that you are dealing with sizes and not other types of integers. This makes the code easier to understand and less prone to errors.
  • Standardization: By using size_t, you are following a widely used and accepted standard, which makes your code more readable and maintainable for other programmers.
  • Interoperability: size_t is widely used in many libraries and APIs, and using it in your code allows for easier integration with other code.

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!