The number of elements in a C array can be determined through the use of the `ARRAY_LENGTH`

macro:

`#define ARRAY_LENGTH(x) (sizeof(x) / sizeof((x)[0]))`

This macro is not a part of the C standard[1], but it is common to find individual codebases defining `ARRAY_LENGTH`

or one of its variants (`ARRAY_LEN`

, `ARRAY_SIZE`

, `ARRAY_COUNT`

, `COUNTOF`

, `NUM_ELEMS`

, etc.) internally.

```
// FILE: example0.c
#include <stdio.h>
#define ARRAY_LENGTH(x) (sizeof(x) / sizeof((x)[0]))
int main(void)
{
int arr0[] = {1, 3, 5};
int arr1[] = {0, 1, 2, 3, 4, 5};
printf("arr0 length == %zu\n", ARRAY_LENGTH(arr0));
printf("arr1 length == %zu\n", ARRAY_LENGTH(arr1));
return 0;
}
```

```
$ c99 example0.c && ./a.out
arr0 length == 3
arr1 length == 6
```

So how does this macro work? Fortunately for us ISO/IEC 9899:1999 (the C99 standard) conveniently spells it all out in section 6.5.3.4 - "The `sizeof`

Operator".

ISO/IEC 9899:1999 sec. 6.5.3.4.2:

The

`sizeof`

operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand. The result is an integer. If the type of the operand is a variable length array type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an integer constant.

ISO/IEC 9899:1999 sec. 6.5.3.4.3:

When applied to an operand that has type

`char`

,`unsigned char`

, or`signed char`

, (or a qualified version thereof) the result is 1. When applied to an operand that has array type, the result is the total number of bytes in the array. When applied to an operand that has structure or union type, the result is the total number of bytes in such an object, including internal and trailing padding.

ISO/IEC 9899:1999 sec. 6.5.3.4.4:

The value of the result is implementation-defined, and its type (an unsigned integer type) is

`size_t`

, defined in`<stddef.h>`

(and other headers).

ISO/IEC 9899:1999 sec. 6.5.3.4.6:

Another use of the

`sizeof`

operator is to compute the number of elements in an array:

`sizeof array / sizeof array[0]`

Say we have an array type `T`

(for example `T`

as type `int[3]`

). Section 6.5.3.4.3 tells us that `sizeof T`

will yield the number of bytes in an array with type `T`

. Expression `T[0]`

has type "element of `T`

", so `sizeof T[0]`

will yield the number of bytes in a single element of an array with type `T`

. The `sizeof`

N elements divided by the `sizeof`

a single element leaves N: the number of elements (length) of `T`

. Section 6.5.3.4.4 tells us that expressions `sizeof T`

and `sizeof T[0]`

both have type `size_t`

, thus the expression `sizeof T / sizeof T[0]`

is also of type `size_t`

.

As a general purpose macro

`#define ARRAY_LENGTH(x) (sizeof(x) / sizeof((x)[0]))`

is preferred over

`#define ARRAY_LENGTH(x) sizeof x / sizeof x[0]`

to avoid errors due to macro parameter substitution. Both macros are conceptually equivalent.

According to section 6.5.3.4.2 `ARRAY_LENGTH`

will yield an integer constant for non-VLA types. Expressions using `ARRAY_LENGTH`

may be used as compile-time integer constant expressions as long as the array in question is not a VLA.

```
// FILE: example1.c
#include <stdio.h>
#define ARRAY_LENGTH(x) (sizeof(x) / sizeof((x)[0]))
static int const primes[] = {2, 3, 5, 7, 11};
enum {PRIMES_LENGTH = ARRAY_LENGTH(primes)}; /* compile time constant */
int main(void)
{
int primes_squared[PRIMES_LENGTH];
for (size_t i = 0; i < PRIMES_LENGTH; ++i)
{
primes_squared[i] = primes[i] * primes[i];
}
puts("PRIME | SQUARED");
puts("---------------");
for (size_t i = 0; i < PRIMES_LENGTH; ++i)
{
printf("%5d | %3d\n", primes[i], primes_squared[i]);
}
return 0;
}
```

```
$ c99 example1.c && ./a.out
PRIME | SQUARED
---------------
2 | 4
3 | 9
5 | 25
7 | 49
11 | 121
```

In most of my own projects I define two variations of this macro.

```
#define ARRAY_COUNT(array_) (sizeof(array_)/sizeof((array_)[0]))
#define CSTR_COUNT(cstr_) (ARRAY_COUNT(cstr_)-1)
```

`ARRAY_COUNT`

is my preferred flavor of `ARRAY_LENGTH`

and `CSTR_COUNT`

is what I use for a compile-time `strlen`

.

```
// FILE: example2.c
#include <stdio.h>
#define ARRAY_COUNT(array_) (sizeof(array_)/sizeof((array_)[0]))
#define CSTR_COUNT(cstr_) (ARRAY_COUNT(cstr_)-1)
#define FOO "foo!"
int main(void)
{
printf("FOO: \"%s\"\n", FOO);
printf("ARRAY_COUNT(FOO) == %zu\n", ARRAY_COUNT(FOO));
printf("CSTR_COUNT(FOO) == %zu\n", CSTR_COUNT(FOO));
return 0;
}
```

```
$ c99 example2.c && ./a.out
FOO: "foo!"
ARRAY_COUNT(FOO) == 5
CSTR_COUNT(FOO) == 4
```

[1]: Sort of... The expression `sizeof array / sizeof array[0]`

actually *does* appear in the standard as we will see shortly. However the `#define`

for `ARRAY_LENGTH`

does not.