Find an Array Size from a Pointer in C

In C, an array has a size only while it is still an array object. When its value is assigned or passed as a function argument, it usually becomes a pointer to its first element. A plain pointer does not contain the array length, so the length must be calculated before decay or supplied separately.

days is an array of five int values. In the scope where it is declared, sizeof days means the total number of bytes occupied by the whole array.

int days[] = {1, 2, 3, 4, 5};

sizeof days        /* 5 * sizeof(int) */
sizeof days[0]     /* sizeof(int) */

You can therefore calculate its element count:

size_t count = sizeof days / sizeof days[0];

However, in most expressions an array decays into a pointer to its first element. This happens here:

int *ptr = days;

After that assignment, ptr stores only an address. It does not store:

• the number of elements,
• the number of bytes allocated,
• where the array ends, or
• whether the memory came from an array, malloc, or another source.

Therefore, sizeof ptr is the size of an int *, not the size of days. This distinction matters because C functions often receive pointers; callers must also provide the length when the function needs to traverse the data.

Think of an array as a row of numbered lockers. The complete row knows how many lockers it contains. A pointer is only a note saying, “Start at locker 1.”

From that note alone, you cannot know whether there are 5 lockers, 50 lockers, or none that you are allowed to access. C does not attach the row length to the address.

Calculate an array length where the variable is truly an array:

#include <stddef.h>

int values[] = {10, 20, 30, 40};
size_t length = sizeof values / sizeof values[0];

• sizeof values is the total size of all elements.
• sizeof values[0] is the size of one element.
• Dividing gives the element count.

A reusable macro is common in C:

#define ARRAY_LEN(array) (sizeof (array) / sizeof (array)[0])

int values[] = {10, 20, 30, 40};
size_t length = ARRAY_LEN(values);  /* 4 */

Use this macro only with actual arrays, not pointers:

int *ptr = values;
size_t wrong = ARRAY_LEN(ptr);  /* Incorrect: ptr is not an array */

Pass a pointer and its length to a function:

#include <stddef.h>
#include <stdio.h>

void print_numbers(const int *numbers, size_t count)
{
    for (size_t i = 0; i < count; i++) {
        printf("%d\n", numbers[i]);
    }
}

int main(void)
{
    int days[] = {1, 2, 3, 4, 5};

    print_numbers(days, sizeof days / sizeof days[0]);
    return 0;
}

days decays to const int * for the first argument, while the second argument preserves the count calculated at the call site.

Consider this example:

int days[] = {1, 2, 3, 4, 5};
int *ptr = days;

size_t bytes = sizeof days;
size_t count = sizeof days / sizeof days[0];
size_t pointer_bytes = sizeof ptr;

Step by step:

1. days is created as an array containing five int elements.
2. ptr = days uses the array's first-element address. It is equivalent to ptr = &days[0] in this context.
3. sizeof days is evaluated using the array type, int[5], so the result is 5 * sizeof(int) bytes.
4. Dividing by sizeof days[0] removes the bytes-per-element part and produces 5.
5. sizeof ptr is evaluated from the type int *. Its result is the storage size of an address on the current platform, not the array size.

For example, if int is 4 bytes and pointers are 8 bytes, bytes is 20, count is 5, and pointer_bytes is 8. Do not assume these particular sizes; C implementations may use different sizes.

• Processing API data: A function receives a buffer plus its count, such as parse_records(records, record_count).
• Binary data: File-reading code tracks both unsigned char *data and the number of bytes read.
• Sorting: Standard-library qsort accepts a base pointer, element count, and element size.
• Embedded systems: Drivers commonly receive a byte buffer and its capacity to avoid reading past it.
• Dynamic arrays: Code using malloc stores the allocated element count in a separate variable or a container structure.

A common C API explicitly accepts a pointer and length:

int sum(const int *items, size_t count)
{
    int total = 0;

    for (size_t i = 0; i < count; i++) {
        total += items[i];
    }

    return total;
}

The caller calculates the count only where it still has the array:

int scores[] = {8, 12, 15};
int total = sum(scores, sizeof scores / sizeof scores[0]);

For dynamically allocated memory, retain metadata yourself:

size_t count = 100;
int *items = malloc(count * sizeof *items);

if (items == NULL) {
    /* Handle allocation failure. */
}

/* Use items with count. */
free(items);

Larger codebases often define a structure to keep related data together:

struct IntArray {
    int *data;
    size_t length;
};

This makes it harder to accidentally pass data without its length.

Using sizeof on a pointer

void print_items(int *items)
{
    size_t count = sizeof items / sizeof items[0]; /* Wrong */
}

Function parameters written as int items[] are also adjusted to int *items, so this is still wrong:

void print_items(int items[]) /* Actually treated as int *items */
{
    size_t count = sizeof items / sizeof items[0]; /* Wrong */
}

Pass count as a separate argument instead.

Confusing bytes with element count

sizeof days returns bytes, not necessarily the number of elements. Divide by the size of one element.

Assuming pointer sizes

A pointer is not guaranteed to be 4 or 8 bytes. It depends on the platform and compiler. Use sizeof ptr only when you specifically need the pointer object's size.

Using the wrong printf format

sizeof produces a size_t. Print it with %zu:

printf("%zu\n", sizeof days);

Using %u is not portable because size_t is not required to be unsigned int.

Scanning until a value “looks like the end”

An int array has no automatic end marker. Reading until a guessed value is unsafe unless your format explicitly defines a sentinel and guarantees it is present. Strings are different because C strings conventionally end with \0.

An array and a pointer are related, but they are not the same type. Arrays often convert to pointers, but that conversion loses size information.

int a[] = {1, 2, 3};

size_t bytes = sizeof a;                 /* Total array bytes */
size_t count = sizeof a / sizeof a[0];   /* 3 elements */

int *p = a;
sizeof p;                                /* Pointer size only */

#define ARRAY_LEN(a) (sizeof (a) / sizeof (a)[0])

Rules:

• Use the sizeof array / sizeof array[0] pattern only where the expression is an actual array.
• A pointer cannot generally reveal how many elements it points to.
• Pass pointer + count to functions that process arrays.
• Use size_t for object sizes and counts.
• Print size_t values with %zu.
• malloc does not make the allocation size recoverable through the returned pointer in portable C; store it yourself.

Can C determine an array's size from an int * pointer?

No. A plain int * contains an address, not an array length. It could point to one element, an array, allocated memory, or invalid memory.

Why does sizeof work for an array but not inside a function?

When an array is passed to a function, it normally converts to a pointer. Inside the function, the parameter has pointer type, so its original array bound is unavailable.

Does int arr[] preserve the array size in a function parameter?

No. In a function parameter list, int arr[] means the same thing as int *arr for this purpose.

Can malloc tell me how many elements were allocated?

Not portably through the returned pointer. Keep the requested count in a size_t variable or a structure.

Why can strlen find a string length from a pointer?

C strings use a convention: a terminating null character ('\0') marks the end. strlen scans until that terminator. Ordinary arrays have no equivalent built-in marker.

Should I use sizeof(*ptr) to get the array size?

No. sizeof *ptr gives the size of one pointed-to element, such as one int. It cannot tell you the number of elements.

Can a variable-length array retain its size?

Yes, while it remains an array in the same scope, sizeof can use its runtime size. But once passed as an ordinary pointer, you should still pass the length separately.

• Array-to-pointer decay — explains why an array loses its bound in many expressions and function calls.
• The sizeof operator — used to obtain object size in bytes when type information is available.
• Pointers in C — pointers hold addresses, not ownership or length metadata.
• Function parameters — array parameters are adjusted to pointer parameters.
• size_t — the standard unsigned type for sizes and element counts.
• Dynamic memory allocation — allocated blocks require separately managed size metadata.
• Null-terminated strings — an important contrast: strings can be measured because they use an end-marker convention.