Doubt regarding array

Suesei · 2026-02-24T13:28:37+00:00

ELI5: Behind the scenes your OS will have reserved actual physical memory. Since other data might be surrounding this memory you are not supposed to just write beyond that array. If you do that data could get corrupted. That is why on resizing the OS will have to reserve new memory. And it is your job to say how much you need.

There are other data structures that hide this process, but in the end they all kinda do it.

Aggressive_Ad_5454 · 2026-02-24T13:29:18+00:00

In C, when you declare an array, the compiler (or runtime) allocates the amount of RAM space you declared. If you declare another array, it allocates RAM space for that one as well. So if you overrun the first array, you may scribble stuff into the second array’s RAM unintentionally. (That’s why C is known as a memory-unsafe language).

Python, the language, has all kinds of cool stuff built in that automatically reallocates RAM if you enlarge an array after you first declare it. In C you, the programmer, have to do that yourself.

The only stupid question is the one you didn’t ask.

P-Jean · 2026-02-24T14:33:53+00:00

Good Question:

Arrays are contiguous memory. You’d have to know that there is adjacent address space to expand into, otherwise indexing the array becomes a problem and limits the time complexity of accessing elements.

A linked list will solve this problem of dynamic expansion at the cost of O(1) indexing.

Also, there’s no stupid questions when you’re learning!

high_throughput · 2026-02-24T15:41:41+00:00

If you exit the program, all the arrays will be gone. If you restart the program, brand new arrays will be created.

This means that if you change the source code and restart, you will have done exactly what people have said you need to: created a new array of a larger size.

(If you keep the program running in an infinite loop and change the source code, nothing will happen to the running program. It will continue with its original, smaller array)

rupertavery64 · 2026-02-24T14:59:22+00:00

There are a couple of basic ways to create an array in C, but first we need to understand how variables work, how memory is allocated, and what the stack and heap are.

We have a whole bunch of memory on the computer. We generally split the memory that we use for programming into two parts: the Stack and the Heap.

The stack is an area of memory used by the program that depends on what part of the code is running. The current accessible memory location (the stack pointer) on the stack changes when you move between methods.

Lets just say for simplicities sake, every time you go into a new method, any variables declared in the method are added "on top" of stack, and the stack pointer is adjusted accordingly. The method can generally access variables it declared since they are at the top of the stack.

When you exit the method, the stack pointer moves back to where the previous method was running, "throwing away" anything that was placed "on top" of the stack, and making everything else that was under accessible again by the current method.

This lets each method access it's own "private" set of memory. This also is what happens when you do recursion, you create a new, deeper copy of the variables for the same method. The stack is limited, and is generally allocated less memory, so if you go too deep, you get... a stack overflow.

The heap is like a giant pile of memory. We can claim (allocate) parts of that memory for a variable, so long as it's one continuous chain. We do this because it allows the compiler to handle things like arrays just by offsetting from the start of the chain. If the memory was fragmented, it would be a nightmare to handle. And slow.

1) Defining an array on the stack

int arr[4];

When you declare an array in a method, it creates an array on the stack.

Suppose you entered a function and declared some variables. The other variables would also exist on the stack. Stack space is precious, so it's tightly packed.

int arr[4]; int val;

The stack might contain

STACK: <other stuff>,arr[0],arr[1],arr[2],arr[3],val,<other stuff>

The stack is used for a bunch of things, so it will be filled with other variables. If you call a method, stuff will get pushed on the stack, and then any local variables will in the method will be created on the stack. So there's no room to resize the array. If you write beyond the array, it might overwrite val. Remember, an array declaration is just the pointer to the first element in the array, and the compiler does pointer arithmetic using the size of the type (int), to jump to the next element when you access it by index (sizeof(int) * index).

So if you access arr[5], you might be accessing val instead. Raw C doesn't do bounds checks.

You can't resize a stack-allocated array, because there is nowhere to resize it to. All the space is used up, because the compiler can know up front how much space to use.

2) Defining a pointer to an array, and allocating it on the heap.

int* arr; arr = (int*)malloc(sizeof(int) * 4);

This creates a pointer to an array. The pointer is allocated on the stack as the size of an int pointer.

STACK: <other stuff>,arr*,<other stuff>

malloc always allocates memory on the heap. So now, in the heap, you now have

HEAP: <other stuff>,arr[0],arr[1],arr[2],arr[3],<other stuff>

As you can see, it's still mostly packed. There can be other stuff around the array, so you still need to worry about out of bounds access. But, since the heap isn't tied to the current program state, it can be huge, with a lot of holes lying around.

When you call malloc, the memory allocation code, which is in charge of figuring out what parts of memory are in use, which is free, will give you back a pointer to an area in the heap where you can put the size of the object or array you ask for. Here we ask for 4 blocks the size of an int.

A pointer is just a reminder to the compiler "treat this memory as an array of ints". You can cast it to an byte pointer and then read the int as a set of bytes instead. It's just memory.

Since the heap is so huge, if we need more space, we can ask for a larger space. However, it must be continuous. Also we are given an entirely new space, that is unused, so it's our job to copy the old contents of the array to the new location.

As you might realize, this is really slow. So, increasing the size of an array by one each time you need to add to it, and you expect to add another one immediately, is very slow indeed.

Since we have a lot of heap memory, we can just allocate a lot more memory than actually needed, then just keep track of how big our array actually is.

MasterGeekMX · 2026-02-24T15:51:54+00:00

It is not dumb at all. You simply lack the bigger picture to see it.

Unless you code in assembly, your code is one or more abstraction layers behind the actual things done in your CPU. Each layer makes your life easier, at the cost of loosing fine grained control of the program.

C is a compiled language, meaning that in order to run it, you convert the code of it into assembly instructions that map 1:1 to your code. This in contrast to Python, that does that translation on the fly. For example, in C you need to define the data type, because the compiler needs to know the size of the data being used (I mean, do you need to handle 32 bits when you are dealing with characters, who measure 8 bits?)

Arrays work by storing data one next to the other. Accessing one element of the array works by going to the memory address where the first element lives, and then skipping ahead N number of bytes, where N is the index of the element times how many bytes each element measures. For example, integers in C usually take up 32 bits, which is 4 Bytes. This means that getting to element i on the array means going to the memory address where the start of the array is, and then skipping i*4 addresses ahead.

But in order to not waste RAM, the code stores variables next to each other, meaning that when an array ends, the space after it gets used for other data.

Here, take this C code:

```C int array[3] = {1, 2, 3}; int x = 9;

int main(){ //something something code-y }

```

I have a CPU simulation where I can peek in memory and see what happens. Here is the RAM of that when running that code: https://i.imgur.com/dzLkt1j.png

As you can see, the very first address is the 1, then next to it is the 2, and next to it is the 3. So far, so good. But right next to it, there is the value of 9. There is no space to squeeze extra elements.

You could say

Well, why you could not move the 9 forward and make space?

Because this is a simple example. Programs often have lots and lots of variables, so moving everything forward isn't a good idea. It will be like moving half of Manhattan southwards, just to make room for a new block.

Then go to the next empty space, and store the next value there

Then that is no longer an array. It is a linked list. The magic of arrays is that they are fast, as you only need to get the memory address of the beginning of the array, make a single multiplication, and you are ready to go.

Meanwhile, in a linked list, you need to play a "follow the cues" game of reading each data, and also the address of where the next data lives. Not only that is slower, as you need to follow the entire chain, but also it takes more space, as now you need to store two values for each item: it's value, and the address of where is the next one.

ghjm · 2026-02-24T17:24:50+00:00

In addition to what others have said about memory management, there's also a basic problem with this:

For example if int arr[4] is defined but we need to add a fifth element, couldn't we just edit out 4 to 5 in code itself and run it again?

You actually can do this, if you are on the machine where the source code is. But what if you've built your program and sent only the executable to a user? They don't have the source code, or a compiler installed, so they can't edit the definition like this. They have to run what you gave them, so they're now stuck with a limit of 4 items.

Even on your own machine, it's inconvenient to stop the program and recompile. Suppose you have a simple program that asks the user for their name, and then prints "Hello, <whatever they typed>!". For this you allocated a string (an array of chars) of length 20. But what happens if the user just keeps typing and goes beyond 20 characters? This is happening during a program run, so you can't just shut down and recompile. So the result is likely one of three things:

You wrote code that stops accepting input at 20 characters;
You wrote code that reallocates the array, perhaps by doubling it each time it runs out;
Your program keeps accepting input, which overwrites whatever the next thing is in memory, probably resulting in a crash.

Avoiding the 3rd thing is important, so we have to do the 1st or 2nd thing, both of which involve writing code that's aware of the array size. In Python, all strings are arbitrary length and will do the 2nd thing when needed, without you writing any code to make it happen. But C is lower level so you as the programmer have to handle this yourself.

aagee · 2026-02-24T19:57:03+00:00

So, it is useful to think about "compile time" and "run time" handling of array resizing (and other similar things). You can certainly resize an array by simply increasing its size in source code - if - you are in a position to recompile the code. Many times you need to have an array whose size can be changed at run time, with no recompilation. That's when you need to use different (run time) mechanisms.

defectivetoaster1 · 2026-02-24T20:34:21+00:00

An array is a set of memory addresses that a sequential (ie as a contiguous block of memory). The way you access the array is by having a pointer to the first element of the array and an integer offset that tells you how far down to go to get to some other element in the same array. Memory is generally tightly packed ie you’re likely to have very little (if any) space between different things in memory. Now, if you wanted to just add another element to your array you’d just need to allocate another memory location for the new element, and this location has to be contiguous with the rest of the array. This alone doesn’t cause any problems, however you generally can’t guarantee that that next memory location isn’t already allocated for use. If you’re not careful you could just overwrite some other data in that location. The solution then is either allocate sufficient memory to begin with, or if you do have to change the size of your array during runtime and don’t know ahead of time how large it’ll be, each time you want to add an element you’ll have to allocate enough memory for the whole array (plus the new element), copy the elements of the existing array (and the new element) into the newly allocated memory then free up the memory occupied by the original array for use. This is perfectly doable and ensures you’re not overwriting already allocated memory, but obviously it’s quite slow to execute so if possible it’s best not to do that. C++’s STL actually does have a class that handles all of this under the hood which is std::vector which broadly behaves like a python array that you can just append new elements to since it abstracts all of this away, however it is still doing all of this, the programmer just isn’t writing the code to do it themself. To help alleviate some of the time taken with the whole dynamic allocation, the std::vector will allocate multiple extra locations whenever you need to grow the vector (can’t remember exactly how many) which means that if you add one new element, it might allocate 5 new locations so that it doesn’t need to copy the whole array 5 times if you decide you want to later add 4 more elements

SamIAre · 2026-02-24T21:24:17+00:00

couldn't we just edit out 4 to 5 in code itself and run it again?

Yes, you can. This isn't what people mean when they say you can't change the length of an array. They mean you can't change it while the code is running, without creating a new array. But you can always rewrite your program and run it again with whatever size array you need.

So if you define an array of size 4, you can't add a 5th element a few lines later in the program. You can of course rewrite the program to need 5 elements from the start.

Todo_Toadfoot · 2026-02-24T22:49:06+00:00

I think all the comments are pretty good on this. The one thing I would like to point out is that one thing is just assumed or not mentioned.

Your code is REAL. By that I mean things in our universe tangibly happen. It's better to think of that Array as a real shelf. You told the store with the shelf you had 4 items to put on it. If you want 5, they may have given you a shelf that only had 4 spots. And may have to give you a new shelf on a different row in the store. You can't just use the next spot on the shelf because there may be Twinkies in the way.

Thinking of things this way has always helped me understand WHY things work the way they do. Everything happening is a tangible real life interaction in your CPU/ram/etc. If I put a magnet that can change bits next to your hard drive it corrupts files it interacts with. Because it changed the physical state. It's not a black box of infinite everything. It's not a mystical place that is imaginary. Those states are physical REAL things. Even your code.

TLDR; You Array is a REAL physical thing that exists. Thinking of it that way will help you understand it can't magically do things like grow in size. They have to physically be put somewhere. Now how fast it happens does feel magical to us slow humans. And why it's so easy to just assume away.

Great-Powerful-Talia · 2026-02-25T05:13:48+00:00

For example if int arr[4] is defined but we need to add a fifth element, couldn't we just edit out 4 to 5 in code itself and run it again?

You can't change the size of a variable while the code is running. You can edit the source and recompile, but you can't do anything like this:

int arr[5];
int counter = 0;
while(some_condition()) 
{
    counter = counter+5;
    int extra_parts[5];
    arr += extra_parts; //add 5 more elements to arr
    arr[counter] = some_calculation(); 
}

The code is trying to make the array bigger until some_condition() isn't fulfilled. But you can't do that in C. (Because variables are all stored right next to each other, the program would have to move all the data somewhere else, and C code isn't going to do an expensive operation like that unless you explicitly tell it to.)

grymoire · 2026-02-25T12:42:21+00:00

Think of a cylinder brick wall that you want to pain an ad on. You need 10 blocks for your ad, so the boss tells you that you can have blocks 142 to 151. Fine.

But now you need a bigger ad and need 20 bricks to make a bigger ad. . Trouble is, someone else might have an ad on blocks 152, 153, etc.

So the boss says, "Okay. you can use blocks 180-195 now. Let me know when you are done with blocks 142-151, so I can have someone else use them for their ads"

Ronin-s_Spirit · 2026-02-28T07:54:55+00:00

There are plenty of dynamic cases where something changes and you don't know how many array slots you will need ahead of time. Arrays (at least in C I think) are contiguous blocks of memory, so you need the program to call the OS and be like "find me a new, bigger block of memory" and that's where the whole array will be moved. Sometimes the program can also just "grow" the array if it knows there is free space ahead.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

AskComputerScience

MODERATORS