 This time, we're going to see how we can implement arrays. An array is really just a specialized type of data structure. It's one where all of the elements in our data structure are the same type. So we can describe these using a limited set of parameters. We just need to know what the data type is and how many of them we have. After that, we'll be able to construct and manipulate arrays the same way we did with data structures. These all have a nice straightforward structure. We just need to know what the size of the data type is and how many elements of that we have. If we want to know the total size, then we just need to multiply the size of the data type by the number of elements that we have in the array. We can also access successive elements in our array just by incrementing by the size of our data type. We saw something similar when we were looking at simple data structures where if our first element was 4 bytes, then we'd skip over those 4 bytes to get to the second element in our data structure. If the second element in our data structure is also 4 bytes, then we'd just go down another 4 bytes to get to the third element in our data structure. Now generally, we construct these statically. We're just going to decide to throw in n elements, and that will be the size of our data structure. If it turned out we guessed wrong and we actually needed more space in our array, we don't normally just tack on other stuff. It's hard to know if there's something after our array already. We wouldn't want to go overriding other pieces of data, and we don't know where the end of our memory is. So if our array is backed up to the edge of our memory, we don't want to allocate more things because we'd never be able to access the space over there anyway. So we don't normally construct variably sized arrays. We normally do them statically. Instead, what we'll do is we'll just go allocate a larger array elsewhere and copy all of the data from our first array into our new array so that we have some space afterwards. So arrays are really just a simple version of a data structure. Everything is just one data type. We have lots of them, but it's just one data type. So they're actually really easy to work with, even though they can be really large.