# How do I determine the size of my array in C?

1122

How do I determine the size of my array in C?

That is, the number of elements the array can hold?

This question is tagged with `c` `arrays` `memory`

1382

Executive summary:

``````int a[17];
size_t n = sizeof(a)/sizeof(a[0]);
``````

To determine the size of your array in bytes, you can use the `sizeof` operator:

``````int a[17];
size_t n = sizeof(a);
``````

On my computer, ints are 4 bytes long, so n is 68.

To determine the number of elements in the array, we can divide the total size of the array by the size of the array element. You could do this with the type, like this:

``````int a[17];
size_t n = sizeof(a) / sizeof(int);
``````

and get the proper answer (68 / 4 = 17), but if the type of `a` changed you would have a nasty bug if you forgot to change the `sizeof(int)` as well.

So the preferred divisor is `sizeof(a[0])` or the equivalent `sizeof(*a)`, the size of the first element of the array.

``````int a[17];
size_t n = sizeof(a) / sizeof(a[0]);
``````

Another advantage is that you can now easily parameterize the array name in a macro and get:

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

int a[17];
size_t n = NELEMS(a);
``````

874

The `sizeof` way is the right way iff you are dealing with arrays not received as parameters. An array sent as a parameter to a function is treated as a pointer, so `sizeof` will return the pointer's size, instead of the array's.

Thus, inside functions this method does not work. Instead, always pass an additional parameter `size_t size` indicating the number of elements in the array.

Test:

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

void printSizeOf(int intArray[]);
void printLength(int intArray[]);

int main(int argc, char* argv[])
{
int array[] = { 0, 1, 2, 3, 4, 5, 6 };

printf("sizeof of array: %d\n", (int) sizeof(array));
printSizeOf(array);

printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));
printLength(array);
}

void printSizeOf(int intArray[])
{
printf("sizeof of parameter: %d\n", (int) sizeof(intArray));
}

void printLength(int intArray[])
{
printf("Length of parameter: %d\n", (int)( sizeof(intArray) / sizeof(intArray[0]) ));
}
``````

Output (in a 64-bit Linux OS):

``````sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2
``````

Output (in a 32-bit windows OS):

``````sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1
``````

144

It is worth noting that `sizeof` doesn't help when dealing with an array value that has decayed to a pointer: even though it points to the start of an array, to the compiler it is the same as a pointer to a single element of that array. A pointer does not "remember" anything else about the array that was used to initialize it.

``````int a[10];
int* p = a;

assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(int*));
assert(sizeof(*p) == sizeof(int));
``````

51

The sizeof "trick" is the best way I know, with one small but (to me, this being a major pet peeve) important change in the use of parenthesis.

As the Wikipedia entry makes clear, C's `sizeof` is not a function; it's an operator. Thus, it does not require parenthesis around its argument, unless the argument is a type name. This is easy to remember, since it makes the argument look like a cast expression, which also uses parenthesis.

So: If you have the following:

``````int myArray[10];
``````

You can find the number of elements with code like this:

``````size_t n = sizeof myArray / sizeof *myArray;
``````

That, to me, reads a lot easier than the alternative with parenthesis. I also favor use of the asterisk in the right-hand part of the division, since it's more concise than indexing.

Of course, this is all compile-time too, so there's no need to worry about the division affecting the performance of the program. So use this form wherever you can.

It is always best to use sizeof on an actual object when you have one, rather than on a type, since then you don't need to worry about making an error and stating the wrong type.

For instance, say you have a function that outputs some data as a stream of bytes, for instance across a network. Let's call the function `send()`, and make it take as arguments a pointer to the object to send, and the number of bytes in the object. So, the prototype becomes:

``````void send(const void *object, size_t size);
``````

And then you need to send an integer, so you code it up like this:

``````int foo = 4711;
send(&foo, sizeof (int));
``````

Now, you've introduced a subtle way of shooting yourself in the foot, by specifying the type of `foo` in two places. If one changes but the other doesn't, the code breaks. Thus, always do it like this:

``````send(&foo, sizeof foo);
``````

Now you're protected. Sure, you duplicate the name of the variable, but that has a high probability of breaking in a way the compiler can detect, if you change it.

39

``````int size = (&arr)[1] - arr;
``````

Check out this link for explanation

26

You can use sizeof operator but it will not work for functions because it will take the reference of pointer you can do the following to find the length of an array:

``````len = sizeof(arr)/sizeof(arr[0])
``````

Code originally found here: C program to find the number of elements in an array

22

I would advise to never use `sizeof` (even if it can be used) to get any of the two different sizes of an array, either in number of elements or in bytes, which are the last two cases I show here. For each of the two sizes, the macros shown below can be used to make it safer. The reason is to make obvious the intention of the code to maintainers, and difference `sizeof(ptr)` from `sizeof(arr)` at first glance (which written this way isn't obvious), so that bugs are then obvious for everyone reading the code.

TL;DR:

``````#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]) + must_be_array(arr))

#define ARRAY_SSIZE(arr)    ((ptrdiff_t)ARRAY_SIZE(arr))

#define ARRAY_BYTES(arr)    (sizeof(arr) + must_be_array(arr))

#define ARRAY_SBYTES(arr)   ((ssize_t)ARRAY_BYTES(arr))
``````

`must_be_array(arr)` (defined below) IS needed as `-Wsizeof-pointer-div` is buggy (as of april/2020):

``````#define is_same_type(a, b)  __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)       (!is_same_type((arr), &(arr)[0]))
#define must_be(e, ...)     (                               \
0 * (int)sizeof(                                                \
struct {                                                \
_Static_assert((e)  __VA_OPT__(,)  __VA_ARGS__);\
char ISO_C_forbids_a_struct_with_no_members__;  \
}                                                       \
)                                                               \
)
#define must_be_array(arr)  must_be(is_array(arr), "Not a `[]` !")
``````

There have been important bugs regarding this topic: https://lkml.org/lkml/2015/9/3/428

I disagree with the solution that Linus provides, which is to never use array notation for parameters of functions.

I like array notation as documentation that a pointer is being used as an array. But that means that a fool-proof solution needs to be applied so that it is impossible to write buggy code.

From an array we have three sizes which we might want to know:

• The size of the elements of the array
• The number of elements in the array
• The size in bytes that the array uses in memory

## The size of the elements of the array

The first one is very simple, and it doesn't matter if we are dealing with an array or a pointer, because it's done the same way.

Example of usage:

``````void foo(ptrdiff_t nmemb, int arr[static nmemb])
{
qsort(arr, nmemb, sizeof(arr[0]), cmp);
}
``````

`qsort()` needs this value as its third argument.

For the other two sizes, which are the topic of the question, we want to make sure that we're dealing with an array, and break the compilation if not, because if we're dealing with a pointer, we will get wrong values. When the compilation is broken, we will be able to easily see that we weren't dealing with an array, but with a pointer instead, and we will just have to write the code with a variable or a macro that stores the size of the array behind the pointer.

## The number of elements in the array

This one is the most common, and many answers have provided you with the typical macro ARRAY_SIZE:

``````#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]))
``````

Given that the result of ARRAY_SIZE is commonly used with signed variables of type `ptrdiff_t`, it is good to define a signed variant of this macro:

``````#define ARRAY_SSIZE(arr)    ((ptrdiff_t)ARRAY_SIZE(arr))
``````

Arrays with more than `PTRDIFF_MAX` members are going to give invalid values for this signed version of the macro, but from reading C17::6.5.6.9, arrays like that are already playing with fire. Only `ARRAY_SIZE` and `size_t` should be used in those cases.

Recent versions of compilers, such as GCC 8, will warn you when you apply this macro to a pointer, so it is safe (there are other methods to make it safe with older compilers).

It works by dividing the size in bytes of the whole array by the size of each element.

Examples of usage:

``````void foo(ptrdiff_t nmemb)
{
char buf[nmemb];

fgets(buf, ARRAY_SIZE(buf), stdin);
}

void bar(ptrdiff_t nmemb)
{
int arr[nmemb];

for (ptrdiff_t i = 0; i < ARRAY_SSIZE(arr); i++)
arr[i] = i;
}
``````

If these functions didn't use arrays, but got them as parameters instead, the former code would not compile, so it would be impossible to have a bug (given that a recent compiler version is used, or that some other trick is used), and we need to replace the macro call by the value:

``````void foo(ptrdiff_t nmemb, char buf[nmemb])
{

fgets(buf, nmemb, stdin);
}

void bar(ptrdiff_t nmemb, int arr[nmemb])
{

for (ptrdiff_t i = 0; i < nmemb; i++)
arr[i] = i;
}
``````

## The size in bytes that the array uses in memory

`ARRAY_SIZE` is commonly used as a solution to the previous case, but this case is rarely written safely, maybe because it's less common.

The common way to get this value is to use `sizeof(arr)`. The problem: the same as with the previous one; if you have a pointer instead of an array, your program will go nuts.

The solution to the problem involves using the same macro as before, which we know to be safe (it breaks compilation if it is applied to a pointer):

``````#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))
``````

Given that the result of ARRAY_BYTES is sometimes compared to the output of functions that return `ssize_t`, it is good to define a signed variant of this macro:

``````#define ARRAY_SBYTES(arr)   ((ssize_t)ARRAY_BYTES(arr))
``````

How it works is very simple: it undoes the division that `ARRAY_SIZE` does, so after mathematical cancellations you end up with just one `sizeof(arr)`, but with the added safety of the `ARRAY_SIZE` construction.

Example of usage:

``````void foo(ptrdiff_t nmemb)
{
int arr[nmemb];

memset(arr, 0, ARRAY_BYTES(arr));
}
``````

`memset()` needs this value as its third argument.

As before, if the array is received as a parameter (a pointer), it won't compile, and we will have to replace the macro call by the value:

``````void foo(ptrdiff_t nmemb, int arr[nmemb])
{

memset(arr, 0, sizeof(arr[0]) * nmemb);
}
``````

### Update (23/apr/2020): `-Wsizeof-pointer-div` is buggy:

Today I found out that the new warning in GCC only works if the macro is defined in a header that is not a system header. If you define the macro in a header that is installed in your system (usually `/usr/local/include/` or `/usr/include/`) (`#include <foo.h>`), the compiler will NOT emit a warning (I tried GCC 9.3.0).

So we have `#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))` and want to make it safe. We will need C11 `_Static_assert()` and some GCC extensions: Statements and Declarations in Expressions, __builtin_types_compatible_p:

``````#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)           (!is_same_type((arr), &(arr)[0]))
#define Static_assert_array(arr) _Static_assert(is_array(arr), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (                                       \
{                                                                       \
Static_assert_array(arr);                                       \
sizeof(arr) / sizeof((arr)[0]);                                \
}                                                                       \
)
``````

Now `ARRAY_SIZE()` is completely safe, and therefore all its derivatives will be safe.

## Update: libbsd provides `__arraycount()`:

Libbsd provides the macro `__arraycount()` in `<sys/cdefs.h>`, which is unsafe because it lacks a pair of parentheses, but we can add those parentheses ourselves, and therefore we don't even need to write the division in our header (why would we duplicate code that already exists?). That macro is defined in a system header, so if we use it we are forced to use the macros above.

``````#include <stddef.h>
#include <sys/cdefs.h>
#include <sys/types.h>

#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)           (!is_same_type((arr), &(arr)[0]))
#define Static_assert_array(arr) _Static_assert(is_array(arr), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (                                       \
{                                                                       \
Static_assert_array(arr);                                       \
__arraycount((arr));                                            \
}                                                                       \
)

#define ARRAY_SSIZE(arr)        ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))
#define ARRAY_SBYTES(arr)       ((ssize_t)ARRAY_BYTES(arr))
``````

Some systems provide `nitems()` in `<sys/param.h>` instead, and some systems provide both. You should check your system, and use the one you have, and maybe use some preprocessor conditionals for portability and support both.

## Update: Allow the macro to be used at file scope:

Unfortunately, the `({})` gcc extension cannot be used at file scope. To be able to use the macro at file scope, the static assertion must be inside `sizeof(struct {})`. Then, multiply it by `0` to not affect the result. A cast to `(int)` might be good to simulate a function that returns `(int)0` (in this case it is not necessary, but then it is reusable for other things).

Additionally, the definition of `ARRAY_BYTES()` can be simplified a bit.

``````#include <stddef.h>
#include <sys/cdefs.h>
#include <sys/types.h>

#define is_same_type(a, b)     __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)          (!is_same_type((arr), &(arr)[0]))
#define must_be(e, ...)        (                                        \
0 * (int)sizeof(                                                \
struct {                                                \
_Static_assert((e)  __VA_OPT__(,)  __VA_ARGS__);\
char ISO_C_forbids_a_struct_with_no_members__;  \
}                                                       \
)                                                               \
)
#define must_be_array(arr)      must_be(is_array(arr), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (__arraycount((arr)) + must_be_array(arr))
#define ARRAY_SSIZE(arr)        ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr)        (sizeof(arr) + must_be_array(arr))
#define ARRAY_SBYTES(arr)       ((ssize_t)ARRAY_BYTES(arr))
``````

# Notes:

This code makes use of the following extensions, which are completely necessary, and their presence is absolutely necessary to achieve safety. If your compiler doesn't have them, or some similar ones, then you can't achieve this level of safety.

I also make use of the following C11 feature. However, its absence by using an older standard can be overcome using some dirty tricks (see for example: What is “:-!!” in C code?).

I also use the following extension, but there's a standard C way of doing the same thing.

22

If you know the data type of the array, you can use something like:

``````int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};

int noofele = sizeof(arr)/sizeof(int);
``````

Or if you don't know the data type of array, you can use something like:

``````noofele = sizeof(arr)/sizeof(arr[0]);
``````

Note: This thing only works if the array is not defined at run time (like malloc) and the array is not passed in a function. In both cases, `arr` (array name) is a pointer.

20

The macro `ARRAYELEMENTCOUNT(x)` that everyone is making use of evaluates incorrectly. This, realistically, is just a sensitive matter, because you can't have expressions that result in an 'array' type.

``````/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x[0]))

ARRAYELEMENTCOUNT(p + 1);
``````

Actually evaluates as:

``````(sizeof (p + 1) / sizeof (p + 1[0]));
``````

Whereas

``````/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x)[0])

ARRAYELEMENTCOUNT(p + 1);
``````

It correctly evaluates to:

``````(sizeof (p + 1) / sizeof (p + 1)[0]);
``````

This really doesn't have a lot to do with the size of arrays explicitly. I've just noticed a lot of errors from not truly observing how the C preprocessor works. You always wrap the macro parameter, not an expression in might be involved in.

This is correct; my example was a bad one. But that's actually exactly what should happen. As I previously mentioned `p + 1` will end up as a pointer type and invalidate the entire macro (just like if you attempted to use the macro in a function with a pointer parameter).

At the end of the day, in this particular instance, the fault doesn't really matter (so I'm just wasting everyone's time; huzzah!), because you don't have expressions with a type of 'array'. But really the point about preprocessor evaluation subtles I think is an important one.

17

For multidimensional arrays it is a tad more complicated. Oftenly people define explicit macro constants, i.e.

``````#define g_rgDialogRows   2
#define g_rgDialogCols   7

static char const* g_rgDialog[g_rgDialogRows][g_rgDialogCols] =
{
{ " ",  " ",    " ",    " 494", " 210", " Generic Sample Dialog", " " },
{ " 1", " 330", " 174", " 88",  " ",    " OK",        " " },
};
``````

But these constants can be evaluated at compile-time too with sizeof:

``````#define rows_of_array(name)       \
(sizeof(name   ) / sizeof(name[0][0]) / columns_of_array(name))
#define columns_of_array(name)    \
(sizeof(name[0]) / sizeof(name[0][0]))

static char* g_rgDialog[][7] = { /* ... */ };

assert(   rows_of_array(g_rgDialog) == 2);
assert(columns_of_array(g_rgDialog) == 7);
``````

Note that this code works in C and C++. For arrays with more than two dimensions use

``````sizeof(name[0][0][0])
sizeof(name[0][0][0][0])
``````

16

Size of an array in C:

``````int a[10];
size_t size_of_array = sizeof(a);      // Size of array a
int n = sizeof (a) / sizeof (a[0]);    // Number of elements in array a
size_t size_of_element = sizeof(a[0]); // Size of each element in array a
// Size of each element = size of type
``````

15

``````sizeof(array) / sizeof(array[0])
``````

12

"you've introduced a subtle way of shooting yourself in the foot"

C 'native' arrays do not store their size. It is therefore recommended to save the length of the array in a separate variable/const, and pass it whenever you pass the array, that is:

``````#define MY_ARRAY_LENGTH   15
int myArray[MY_ARRAY_LENGTH];
``````

You SHOULD always avoid native arrays (unless you can't, in which case, mind your foot). If you are writing C++, use the STL's 'vector' container. "Compared to arrays, they provide almost the same performance", and they are far more useful!

``````// vector is a template, the <int> means it is a vector of ints
vector<int> numbers;

// push_back() puts a new value at the end (or back) of the vector
for (int i = 0; i < 10; i++)
numbers.push_back(i);

// Determine the size of the array
cout << numbers.size();
``````

11

``````#define SIZE_OF_ARRAY(_array) (sizeof(_array) / sizeof(_array[0]))
``````

5

If you really want to do this to pass around your array I suggest implementing a structure to store a pointer to the type you want an array of and an integer representing the size of the array. Then you can pass that around to your functions. Just assign the array variable value (pointer to first element) to that pointer. Then you can go `Array.arr[i]` to get the i-th element and use `Array.size` to get the number of elements in the array.

I included some code for you. It's not very useful but you could extend it with more features. To be honest though, if these are the things you want you should stop using C and use another language with these features built in.

``````/* Absolutely no one should use this...
By the time you're done implementing it you'll wish you just passed around
an array and size to your functions */
/* This is a static implementation. You can get a dynamic implementation and
cut out the array in main by using the stdlib memory allocation methods,
but it will work much slower since it will store your array on the heap */

#include <stdio.h>
#include <string.h>
/*
#include "MyTypeArray.h"
*/
/* MyTypeArray.h
#ifndef MYTYPE_ARRAY
#define MYTYPE_ARRAY
*/
typedef struct MyType
{
int age;
char name[20];
} MyType;
typedef struct MyTypeArray
{
int size;
MyType *arr;
} MyTypeArray;

MyType new_MyType(int age, char *name);
MyTypeArray newMyTypeArray(int size, MyType *first);
/*
#endif
End MyTypeArray.h */

/* MyTypeArray.c */
MyType new_MyType(int age, char *name)
{
MyType d;
d.age = age;
strcpy(d.name, name);
return d;
}

MyTypeArray new_MyTypeArray(int size, MyType *first)
{
MyTypeArray d;
d.size = size;
d.arr = first;
return d;
}
/* End MyTypeArray.c */

void print_MyType_names(MyTypeArray d)
{
int i;
for (i = 0; i < d.size; i++)
{
printf("Name: %s, Age: %d\n", d.arr[i].name, d.arr[i].age);
}
}

int main()
{
/* First create an array on the stack to store our elements in.
Note we could create an empty array with a size instead and
set the elements later. */
MyType arr[] = {new_MyType(10, "Sam"), new_MyType(3, "Baxter")};
/* Now create a "MyTypeArray" which will use the array we just
created internally. Really it will just store the value of the pointer
"arr". Here we are manually setting the size. You can use the sizeof
trick here instead if you're sure it will work with your compiler. */
MyTypeArray array = new_MyTypeArray(2, arr);
/* MyTypeArray array = new_MyTypeArray(sizeof(arr)/sizeof(arr[0]), arr); */
print_MyType_names(array);
return 0;
}
``````

4

The best way is you save this information, for example, in a structure:

``````typedef struct {
int *array;
int elements;
} list_s;
``````

Implement all necessary functions such as create, destroy, check equality, and everything else you need. It is easier to pass as a parameter.

4

The function `sizeof` returns the number of bytes which is used by your array in the memory. If you want to calculate the number of elements in your array, you should divide that number with the `sizeof` variable type of the array. Let's say `int array[10];`, if variable type integer in your computer is 32 bit (or 4 bytes), in order to get the size of your array, you should do the following:

``````int array[10];
int sizeOfArray = sizeof(array)/sizeof(int);
``````

2

A more elegant solution will be

``````size_t size = sizeof(a) / sizeof(*a);
``````

2

You can use the `&` operator. Here is the source code:

``````#include<stdio.h>
#include<stdlib.h>
int main(){

int a[10];

int *p;

printf("%p\n", (void *)a);
printf("%p\n", (void *)(&a+1));
printf("---- diff----\n");
printf("%zu\n", sizeof(a[0]));
printf("The size of array a is %zu\n", ((char *)(&a+1)-(char *)a)/(sizeof(a[0])));

return 0;
};
``````

Here is the sample output

``````1549216672
1549216712
---- diff----
4
The size of array a is 10
``````

2

``````#include <stdio.h>

int main(void) {

int a[] = {2,3,4,5,4,5,6,78,9,91,435,4,5,76,7,34};//for Example only
int size;

size = sizeof(a)/sizeof(a[0]);//Method

printf ("size = %d",size);
return 0;
}
``````

-1

Beside the answers already provided, I want to point out a special case by the use of

``````sizeof(a) / sizeof (a[0])
``````

If `a` is either an array of `char`, `unsigned char` or `signed char` you do not need to use `sizeof` twice since a `sizeof` expression with one operand of these types do always result to `1`.

Quote from C18,6.5.3.4/4:

"When `sizeof` is applied to an operand that has type `char`, `unsigned char`, or `signed char`, (or a qualified version thereof) the result is `1`."

Thus, `sizeof(a) / sizeof (a[0])` would be equivalent to `NUMBER OF ARRAY ELEMENTS / 1` if `a` is an array of type `char`, `unsigned char` or `signed char`. The division through 1 is redundant.

In this case, you can simply abbreviate and do:

``````sizeof(a)
``````

For example:

``````char a[10];
size_t length = sizeof(a);
``````

If you want a proof, here is a link to GodBolt.

Nonetheless, the division maintains safety, if the type significantly changes (although these cases are rare).

``````int a[10];