What is an array?:

An array is a series of contiguously allocated variables of the same type. When pointers are learned, we can use then for manipulating arrays effectively. Note that due to alignment, an array will require a memory alignment equal to the sizeof() the type of the array's elements. Alignment just specifies that the first address starts on some multiple of the alignment as a memory location. There can be problems accessing unaligned data, which is why you should NOT try to access array data with any datatype of a larger size than the datatype of the array itself. Also note that arrays are always allocated with offset going upwards in RAM locations, your stack doesn't need to grow upwards for this. Arrays are useful even without pointers because they allow us to use control loops to access elements in order.

How is an array declared/initialized and accessed?:

The syntax for array declaration is:

int variable1[10];

If you wished to create an array of 10 ints, called variable 1. Now, throughout the program, whenever the compiler sees "variable1",it replaces it with the address of variable1 (note: technically it replaces it with the offset from the current scope). The syntax for accessing an element of the array is as follows:

variable1[x]

This accesses the x+1th element of the array. Why x+1? Because, variable1 is the start of the array. To access that location, you access the memory address of variable1. Accessing address (variable1 + n * sizeof(int)) accesses the n+1th element of the array. We simply use the operator[] to simplify this. Note that this method of accessing the n+1th element is called zero-indexing, and people will commonly say you start by accessing the zeroth element, and work up from there, so you are actually accessing the nth element, just that it's zero-indexed. An error caused by this mistake of forgetting about this little fact is called an "off by one" error. Note that it is acceptable to use notation n[variable1], but using it is very highly frowned upon. There is literally no reason you could ever want to use it, unless you are trying to obfuscate code. The syntax for assigning to an array's element is as follows:

variable1[n] = x;

This snippet will assign the value of x to the address equivalent to the nth element of variable1 (if you are using zero-indexing, else it's the n+1th element). To assign the entire array a set of values, the computer can contiguously write data over. This can, however, only be done at array declaration, and is called static initialisation. The syntax is as follows: int variable1[] = {/*Set of values to assign*/}; Note that the set of values must be static, and that you cannot assign less (or more, of course) data than your array can store. You CAN put the size of the array within the square brackets, but it is unnecessary, as the compiler can figure out the size. Note that an array cannot necessarily be of variable length. What is meant by this, is that it is an optional features for compilers to offer, having the size of an array not be compile-time determined. Note that no array can change in size - what is meant is that if you want to take a user input and then create an array of the length of the input, then , while the size of the array is static, it isn't known at compile time. In C99, VLAs (Variable-Length Arrays, as they are called) are a mandatory feature, that then became optional in later standards. Note that the major compilers all allow VLAs.

Extra:

The way arrays are placed in memory is so that the name of the array is actually the address of the lowest element in memory, so that higher elements are accessed by doing addition, as may be intuitive. However, a confusing part of this is that the stack grows downwards. What is meant by this is that the stack pointer (sp/esp/rsp - for accessing 16/32/64 its repectively) points to the top of the stack (often the top of the memory) allocated to the program, unless you use special settings (which you shouldn't), or you are on a special system. When you allocate to the stack, variables are allocated going downwards - so when you push (add) a value (or variable) onto the stack, sp/esp/rsp decreases to be pointing to available unused memory, and when you pop (remove) a value (or variable), esp increases to be pointing to the memory above the variable you popped. When you allocate an array, sp/esp/rsp is decreased by that array's size, and the name for the array is saved as it's offset from the frame of course. This means that, while allocated backwards, because it is allocated all at once, the array is accessed upwards. Note that the reason for the direction of stack growth is dynamic memory: dynamic memory, or heap memory, must grow upwards, as otherwise increases/decreases would have to apply to the start of the chunks of memory. Noting this, having both segments grow towards each other is the only safe way to properly allocate memory to actually maximise availability, otherwise there would be a split, making programs that utilise one more than the average suffer due to lack of available memory. Small note: in terms of actual, physical addresses, things get more complicated due to paging, segments and something called a GDT. However, there are literally 2 things that require knowledge about these things: writing an OS and writing drivers, which is part of writing an OS.