Executive summary:

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

---

Full answer:

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

Copyint 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:

Copyint 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.

Copyint 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:

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

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

C is case sensitive, and the operator you are thinking of is spelled sizeof, not sizeOf. sizeof(Person) is not valid C unless there's a typedef struct Person Person; somewhere that you failed to include in your post; you have to write sizeof(struct Person). myArray is not dynamic, it is either automatic or static (depending on whether this code is located within a function or at the top level) and its size is a compile-time constant. Initializing arraySize to sizeof(myArray) / structSize is not permitted at the top level since structSize is a regular variable and not a compile-time constant. It is however permitted in a function (in C99 and later). sizeof(array) / sizeof(array[0]) is a common construct to calculate the number of items in an automatic or static array at compile time, and is a compile-time constant. Some C implementations provide a nitems() macro which does this. There is no way to determine the size of a dynamic (i.e. allocated) array at compile time or at run time. If you need the size for later, you are simply going to have to store it somewhere when you allocate the array. Some allocators provide a way to retrieve the actual size of an allocation after the fact, but this may be larger than the requested size due to rounding. Small allocations are likely to get rounded up to the nearest power of two, or the nearest bucket size, while large allocations are likely to get rounded up to the nearest multiple of the virtual memory page size.

The allocator needs to keep that information itself. There's a couple of approaches at doing this. The straight-forward way is for the memory allocator to keep a small amount of metadata for of each memory allocation. That metadata would contain the size of the allocation (the size you passed to malloc rounded up to a more convenient value). When you pass back a pointer to free, it can use that size to know how big the allocation was. A common approach is for the metadata to be placed in memory immediately before the pointer given to the program in malloc. Another approach is for the memory to be allocated from a slab of equal-sized blocks. There might be a slab that allocates 8-byte blocks, a slab for 16-byte blocks, a slab for 32-byte blocks, and so on. If you malloc(12), say, the allocator gives the program one of the 16-byte blocks. When the pointer is passed back to free, the memory allocator knows how big the allocation was since it can determine which slab the pointer came from. The allocator still needs to keep some metadata to know which blocks within a slab have been allocated, but not as much as would be needed to track the size of each allocation individually. C is fairly agnostic as to what a pointer actually is, so I suppose you could even have a C implementation with fat pointers that also encoded the sizes (or perhaps their bounds) of their allocations. I'm not sure if any system ever worked this way though.

int is a 32-bit (= 4 byte) data type, so sizeof(array) returns the number of elements times the size in bytes of a single object. A common way of getting the length of an array in C is sizeof(array)/sizeof(array[0]).

The maximum size of an array is determined by the amount of memory that a program can access. On a 32-bit system, the maximum amount of memory that can be addressed by a pointer is 2^32 bytes which is 4 gigabytes. The actual limit may be less, depending on operating system implementation details. I believe that on most 32-bit Linux systems, 1 GB is reserved for the kernel, so the virtual address space of any given application for user data is 3 GB. All the application's code and data are mapped into this 3 GB address space, so the amount of contiguous address space available for a single array is even less. Your array amounts to about 2.6 GB, so I am not the least bit surprised that you ran into trouble. Note that this has nothing to do with the amount of physical memory you have available. Even on a machine with substantially less than 1 GB of RAM, you can allocate a 2 GB array... it's just going to be slow, as most of the array will be in virtual memory, swapped out to disk. The limitation you are up against is the 32-bit address space. Therefore, even if your machine has more than 4 GB of RAM that can be accessed through PAE, individual applications won't be able to access more than 4 (3) GB directly, only through using additional libraries that allow user-level access to to PAE. Given your question, however, you may be running into another issue. Your question indicates that you get an error while compiling your code. This suggests that your monster array is declared as local to a function. Local variables are allocated on the stack, and the stack size is usually much less than gigabytes, and while it is possible to increase the stack size, it's not necessarily a good idea. (Sorry, I don't know off the top of my head how GCC, which I presume is the compiler you use, determines the stack size and what command lines influence it.) So if you need a very large array, you are better off allocating it on the heap, either as a global variable, or allocating it dynamically (using malloc in C, or the new operator in C++).