What is size_t in C?

size_t is an unsigned integer type in C (and C++) used for representing the size of objects or the result of the sizeof operator. Typically, it’s defined as an alias for some underlying unsigned integer type that can hold the maximum size of a theoretically possible object on the target platform. For example, on a 32-bit system, size_t might be unsigned int, whereas on a 64-bit system, it might be unsigned long long.

Key Characteristics

1. Unsigned Integer Type

   • size_t cannot represent negative values, making it suitable for sizes and counts of objects.

2. Platform-Dependent

   • On a 32-bit machine, it usually has 32 bits of storage; on a 64-bit machine, 64 bits, etc. You can’t rely on it to be a specific built-in C type, only that it’s an unsigned integer large enough to represent the size of the largest possible object on that platform.

3. Used by Standard Library Functions

   • Functions like malloc, calloc, and realloc use size_t to specify the number of bytes to allocate.
   • The sizeof operator returns a size_t.
   • It’s widely used in standard library functions that deal with array indices or object counts (e.g., strlen returns a size_t).

Example Usage

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t n = 10;
    int *array = malloc(n * sizeof(int));
    if (!array) {
        return 1; // handle allocation failure
    }

    // Example: fill the array
    for (size_t i = 0; i < n; i++) {
        array[i] = (int)i;
    }

    // Print out the elements
    for (size_t i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }

    free(array);
    return 0;
}

• Here, n is a size_t, ensuring it can hold the array size up to the maximum for the given system.

Why Use size_t?

1. Portability: It automatically adapts to the platform’s pointer size and memory addressing range, making your code more portable.
2. Clarity: Indicates the variable represents a size or count, which is standard practice in system-level programming.
3. Avoids Bugs: Using an unsigned type for sizes helps prevent certain classes of logical and overflow errors.

Further Learning

If you want to deepen your knowledge of C programming—particularly around memory, data structures, and language fundamentals—two recommended courses from DesignGurus.io are:

1. Grokking Data Structures & Algorithms for Coding Interviews

   • Dive deep into arrays, lists, trees, graphs, and more. Learn how to implement them in C or other languages, with a focus on complexity and memory management.

2. Grokking the Coding Interview: Patterns for Coding Questions

   • Master the fundamental coding patterns that appear repeatedly in interviews, helping you recognize solutions faster and write cleaner code.

By properly utilizing size_t and understanding when and why it’s used, you’ll write more robust, portable C code that aligns with standard library conventions.