Tag C strings

Length of Array in C: A Comprehensive Tutorial

The length of an array in C refers to the maximum number of elements that an array can hold. Unlike higher-level languages that provide built-in functions or properties for array length, C requires manual calculation. Understanding how to determine array length correctly is essential for writing safe, efficient, and bug-free C programs.

This tutorial provides an in-depth exploration of finding array length in C: the sizeof method, pointer arithmetic trick, limitations due to array decay, practical applications, common pitfalls, and best practices.

Conceptual Introduction & Fundamentals

What is Array Length?

Array length (also called array size) is the number of elements an array can store. It is determined at the time of declaration and cannot be changed for static arrays.

Example:

c

int arr[5]; // Array length is 5 int matrix[3][4]; // Array length is 12 (3 × 4)

Why Array Length Matters

• Loop bounds: Prevent out-of-bounds access.
• Memory allocation: Know how much memory is used.
• Function parameters: Pass size information to functions.
• Algorithm implementation: Many algorithms require array size.
• Safety: Avoid buffer overflows and undefined behavior.

The Challenge: No Built-in Length

C does not provide a built-in function or property to get array length. You must calculate it manually. The most common method uses the sizeof operator:

c

int arr[5]; size_t length = sizeof(arr) / sizeof(arr[0]);

Array Decay Problem

When an array is passed to a function, it decays to a pointer, losing its size information. Therefore, methods that work in the same scope as the array declaration will fail inside functions.

c

void func(int arr[]) { sizeof(arr); // Returns pointer size, not array size }

Syntax & Core Mechanics

Method 1: sizeof Operator

The simplest and most reliable method within the same scope.

Syntax:

c

size_t length = sizeof(array) / sizeof(array[0]);

Example:

c

#include <stdio.h> int main(void) { int arr[5] = {1, 2, 3, 4, 5}; size_t length = sizeof(arr) / sizeof(arr[0]); printf("Array length: %zu\n", length); printf("Total bytes: %zu\n", sizeof(arr)); printf("Element bytes: %zu\n", sizeof(arr[0])); return 0; }

Expected output:

text

Array length: 5 Total bytes: 20 Element bytes: 4

Method 2: Pointer Arithmetic Trick

A less common method that uses pointer arithmetic.

Syntax:

c

size_t length = *(&array + 1) - array;

Example:

c

#include <stdio.h> int main(void) { int arr[5] = {1, 2, 3, 4, 5}; size_t length = *(&arr + 1) - arr; printf("Array length: %zu\n", length); return 0; }

Expected output:

text

Array length: 5

How it works:

1. &arr — Address of the entire array (type: int (*)[5]).
2. &arr + 1 — Moves pointer to just past the end of the array.
3. *(&arr + 1) — Dereferences to get address just after the array.
4. Subtracting arr (base address) gives the element count.

Method 3: Macro for Array Length

Define a macro for convenience:

c

#include <stdio.h> #define ARRAY_LENGTH(arr) (sizeof(arr) / sizeof((arr)[0])) int main(void) { int arr[5] = {1, 2, 3, 4, 5}; double values[10] = {0}; printf("arr length: %zu\n", ARRAY_LENGTH(arr)); printf("values length: %zu\n", ARRAY_LENGTH(values)); return 0; }

Expected output:

text

arr length: 5 values length: 10

Method 4: For Character Arrays (Strings)

For character arrays containing strings, use strlen for the string length (excluding null terminator) or sizeof for the array capacity.

c

#include <stdio.h> #include <string.h> int main(void) { char str[20] = "Hello"; size_t capacity = sizeof(str); // 20 (total capacity) size_t stringLength = strlen(str); // 5 (actual string length) printf("Capacity: %zu\n", capacity); printf("String length: %zu\n", stringLength); return 0; }

Expected output:

text

Capacity: 20 String length: 5

Method 5: For Multidimensional Arrays

For multidimensional arrays, sizeof gives total elements when divided by element size.

c

#include <stdio.h> int main(void) { int matrix[3][4]; size_t totalElements = sizeof(matrix) / sizeof(matrix[0][0]); size_t rows = sizeof(matrix) / sizeof(matrix[0]); size_t cols = sizeof(matrix[0]) / sizeof(matrix[0][0]); printf("Total elements: %zu\n", totalElements); printf("Rows: %zu\n", rows); printf("Cols: %zu\n", cols); return 0; }

Expected output:

text

Total elements: 12 Rows: 3 Cols: 4

Full Practical Code Example with Explanation

This program demonstrates multiple methods to find array length in different contexts, including the array decay problem.

Program: Array Length Calculator

c

/** * array_length.c * Demonstrates methods to find array length in C. * Shows sizeof method, pointer trick, and array decay problem. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #define MAX_LINE_LEN 100 #define ARRAY_LENGTH(arr) (sizeof(arr) / sizeof((arr)[0])) /* Function prototypes */ void demonstrateSizeofMethod(void); void demonstratePointerTrick(void); void demonstrateMacroMethod(void); void demonstrateMultidimensional(void); void demonstrateArrayDecay(int arr[], size_t size); void demonstrateStringLength(void); int readInteger(const char *prompt, int *outValue); int main(void) { int choice; char buffer[MAX_LINE_LEN]; printf("=== Array Length Calculator ===\n"); while (1) { printf("\n--- Menu ---\n"); printf("1. sizeof Method\n"); printf("2. Pointer Arithmetic Trick\n"); printf("3. Macro Method\n"); printf("4. Multidimensional Array\n"); printf("5. Array Decay Problem\n"); printf("6. String Length vs Capacity\n"); printf("7. Exit\n"); printf("Enter choice: "); fflush(stdout); if (fgets(buffer, sizeof(buffer), stdin) == NULL) { fprintf(stderr, "Error reading choice.\n"); return EXIT_FAILURE; } choice = atoi(buffer); switch (choice) { case 1: demonstrateSizeofMethod(); break; case 2: demonstratePointerTrick(); break; case 3: demonstrateMacroMethod(); break; case 4: demonstrateMultidimensional(); break; case 5: { int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; size_t size = ARRAY_LENGTH(arr); printf("\nIn main: array length = %zu\n", size); demonstrateArrayDecay(arr, size); break; } case 6: demonstrateStringLength(); break; case 7: printf("Exiting.\n"); return EXIT_SUCCESS; default: printf("Invalid choice. Please try again.\n"); break; } } return EXIT_SUCCESS; } /* Demonstrates sizeof method */ void demonstrateSizeofMethod(void) { printf("\n=== sizeof Method ===\n"); int arr[5] = {1, 2, 3, 4, 5}; size_t totalBytes = sizeof(arr); size_t elementBytes = sizeof(arr[0]); size_t length = totalBytes / elementBytes; printf("Array: [1, 2, 3, 4, 5]\n"); printf("Total bytes: %zu\n", totalBytes); printf("Element bytes: %zu\n", elementBytes); printf("Length: %zu\n", length); /* Also works for other types */ double doubleArr[4] = {1.5, 2.5, 3.5, 4.5}; size_t doubleLength = sizeof(doubleArr) / sizeof(doubleArr[0]); printf("\nDouble array length: %zu\n", doubleLength); char charArr[10] = "Hello"; size_t charLength = sizeof(charArr) / sizeof(charArr[0]); printf("Char array capacity: %zu\n", charLength); } /* Demonstrates pointer arithmetic trick */ void demonstratePointerTrick(void) { printf("\n=== Pointer Arithmetic Trick ===\n"); int arr[5] = {1, 2, 3, 4, 5}; size_t length = *(&arr + 1) - arr; printf("Array: [1, 2, 3, 4, 5]\n"); printf("Length using pointer trick: %zu\n", length); /* Explanation */ printf("\nExplanation:\n"); printf("&arr = %p\n", (void*)&arr); printf("&arr + 1 = %p\n", (void*)(&arr + 1)); printf("arr = %p\n", (void*)arr); printf("*(&arr + 1) - arr = %zu\n", length); } /* Demonstrates macro method */ void demonstrateMacroMethod(void) { printf("\n=== Macro Method ===\n"); int arr[7] = {1, 2, 3, 4, 5, 6, 7}; double values[12] = {0}; char text[25] = "Hello"; printf("int arr[7] length: %zu\n", ARRAY_LENGTH(arr)); printf("double values[12] length: %zu\n", ARRAY_LENGTH(values)); printf("char text[25] capacity: %zu\n", ARRAY_LENGTH(text)); } /* Demonstrates multidimensional array length */ void demonstrateMultidimensional(void) { printf("\n=== Multidimensional Array ===\n"); int matrix[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }; size_t totalElements = sizeof(matrix) / sizeof(matrix[0][0]); size_t rows = sizeof(matrix) / sizeof(matrix[0]); size_t cols = sizeof(matrix[0]) / sizeof(matrix[0][0]); printf("3x4 Matrix\n"); printf("Total elements: %zu\n", totalElements); printf("Rows: %zu\n", rows); printf("Columns: %zu\n", cols); int cube[2][3][2] = {{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}}; size_t total3D = sizeof(cube) / sizeof(cube[0][0][0]); printf("\n2x3x2 Cube\n"); printf("Total elements: %zu\n", total3D); } /* Demonstrates array decay problem */ void demonstrateArrayDecay(int arr[], size_t size) { printf("In function: sizeof(arr) = %zu bytes (pointer size)\n", sizeof(arr)); printf("In function: ARRAY_LENGTH(arr) = %zu (incorrect!)\n", ARRAY_LENGTH(arr)); printf("Passed size: %zu (correct)\n", size); } /* Demonstrates string length vs capacity */ void demonstrateStringLength(void) { printf("\n=== String Length vs Capacity ===\n"); char str[20] = "Hello"; size_t capacity = sizeof(str); size_t stringLength = strlen(str); printf("String: \"%s\"\n", str); printf("Array capacity: %zu\n", capacity); printf("String length (strlen): %zu\n", stringLength); printf("Null terminator: %c\n", str[stringLength] == '\0' ? 'Y' : 'N'); } /* Reads an integer safely */ int readInteger(const char *prompt, int *outValue) { char buffer[MAX_LINE_LEN]; char *endPtr; long val; printf("%s", prompt); fflush(stdout); if (fgets(buffer, sizeof(buffer), stdin) == NULL) { return -1; } errno = 0; val = strtol(buffer, &endPtr, 10); if (endPtr == buffer || (*endPtr != '\n' && *endPtr != '\0')) { return -1; } if (errno == ERANGE || val < -2147483647 - 1 || val > 2147483647) { return -1; } *outValue = (int)val; return 0; }

Explanation

1. sizeof Method: Divides total bytes by element bytes.
2. Pointer Trick: Uses pointer arithmetic to calculate length.
3. Macro: Defines reusable ARRAY_LENGTH macro.
4. Multidimensional: Calculates total elements, rows, and columns.
5. Array Decay: Shows why methods fail inside functions.
6. String Length: Distinguishes between capacity and actual string length.

Expected Output (sample run)

text

=== Array Length Calculator === --- Menu --- 1. sizeof Method 2. Pointer Arithmetic Trick 3. Macro Method 4. Multidimensional Array 5. Array Decay Problem 6. String Length vs Capacity 7. Exit Enter choice: 1 === sizeof Method === Array: [1, 2, 3, 4, 5] Total bytes: 20 Element bytes: 4 Length: 5 Double array length: 4 Char array capacity: 10 --- Menu --- ... Enter choice: 5 In main: array length = 10 In function: sizeof(arr) = 8 bytes (pointer size) In function: ARRAY_LENGTH(arr) = 2 (incorrect!) Passed size: 10 (correct) --- Menu --- ... Enter choice: 6 === String Length vs Capacity === String: "Hello" Array capacity: 20 String length (strlen): 5 Null terminator: Y

Common Pitfalls, Edge Cases & Memory Considerations

1. Array Decay in Functions

Using sizeof on an array parameter gives pointer size, not array size.

c

void func(int arr[]) { size_t length = sizeof(arr) / sizeof(arr[0]); // BUG: gives pointer/element // On 64-bit: 8 / 4 = 2 (incorrect) }

Solution: Pass array size as a separate parameter.

2. sizeof on Dynamic Arrays

sizeof on a pointer to dynamically allocated memory gives pointer size, not allocated size.

c

int *arr = malloc(10 * sizeof(int)); size_t length = sizeof(arr) / sizeof(arr[0]); // BUG: pointer/element

Solution: Track the allocated size manually.

3. Empty Arrays

C does not support zero-length arrays as standard (except as compiler extensions).

c

int arr[0]; // Non-standard, may not compile

Solution: Use NULL pointer for empty arrays, or minimum size 1.

4. Character Arrays and strlen

strlen returns the string length (up to null terminator), not the array capacity.

c

char str[100] = "Hi"; size_t len = strlen(str); // 2, not 100 size_t cap = sizeof(str); // 100

Solution: Use sizeof for capacity, strlen for string length.

5. Pointer Arithmetic Trick Limitations

The pointer trick *(&arr + 1) - arr only works when arr is a true array, not a pointer.

c

void func(int *arr) { size_t len = *(&arr + 1) - arr; // BUG: arr is a pointer }

Solution: Only use the trick in the same scope as the array declaration.

6. Macro Side Effects

Macros that evaluate their arguments multiple times can cause side effects.

c

#define ARRAY_LENGTH(arr) (sizeof(arr) / sizeof((arr)[0])) ARRAY_LENGTH(arr++); // arr++ evaluated twice (not actually valid syntax)

Solution: Use the macro only with simple array names, not expressions.

7. Multidimensional Array Confusion

Using sizeof on a row vs. the entire array gives different results.

c

int matrix[3][4]; sizeof(matrix); // 48 (entire array) sizeof(matrix[0]); // 16 (one row) sizeof(matrix[0][0]); // 4 (one element)

Solution: Be clear about what you’re measuring.

8. sizeof on Incomplete Types

Arrays with incomplete types (e.g., extern int arr[]) cannot use sizeof.

c

extern int arr[]; size_t len = sizeof(arr); // Error: invalid application of sizeof

Solution: Define the array with a known size before using sizeof.

9. Variable-Length Arrays (VLA)

C99 supports VLAs where sizeof is evaluated at runtime.

c

int n = 10; int arr[n]; size_t len = sizeof(arr) / sizeof(arr[0]); // Works, but evaluated at runtime

Solution: Be aware that VLA sizeof is not compile-time.

10. Memory Considerations

• sizeof is a compile-time operator (except for VLAs).
• Array length calculation uses no extra memory.
• Tracking array size in a variable uses minimal memory.
• For large arrays, use size_t to avoid integer overflow.

Summary & Best Practices

Finding array length in C requires manual calculation using sizeof. The method works reliably in the same scope as the array declaration but fails when arrays decay to pointers in functions.

Key Takeaways

• Use sizeof(arr) / sizeof(arr[0]) for array length.
• Pointer trick: *(&arr + 1) - arr (same scope only).
• Macro: #define ARRAY_LENGTH(arr) (sizeof(arr) / sizeof((arr)[0])).
• Array decay: Functions receive pointers, losing size information.
• Pass array size explicitly to functions.
• For strings, use strlen for length, sizeof for capacity.

Best Practices

1. Use size_t for array lengths to avoid overflow.
2. Pass array size explicitly to functions.
3. Use a macro for consistent length calculation.
4. Track dynamic array sizes manually when using malloc.
5. Distinguish between capacity and string length for character arrays.
6. Avoid using sizeof on function parameters (they are pointers).
7. Use const arrays when the size should not change.
8. Document the array size in comments for clarity.
9. Test edge cases: empty arrays, single element, multidimensional.
10. Consider using _Static_assert (C11) to verify array sizes at compile time.

By mastering array length calculation, you’ll write safer C code that avoids out-of-bounds access and handles arrays correctly in all contexts.