Question

I have a function which grows an array when trying to add an element if it is full. Which of the execution blocks is better or faster?

I think my second block (commented out) may be wrong, because after doubling my array I then go back and point to the original.

When creating arrays does the compiler look for a contiguous block in memory which it entirely fits into? (On the stack/heap? I don’t fully understand which, though it is important for me to learn it is irrelevant to the actual question.)

If so, would this mean using the second block could potentially overwrite other information by overwriting adjacent memory? (Since the original would use 20 adjacent blocks of memory, and the latter 40.)

Or would it just mean the location of elements in my array would be split, causing poor performance?

void Grow()
{
  length *= 2; // double the size of our stack

  // create temp pointer to this double sized array
  int* tempStack = new int[length];

  // loop the same number of times as original size
  for(int i = 0; i < (length / 2); i++) 
  {
    // copy the elements from the original array to the temp one
    tempStack[i] = myStack[i]; 
  }

  delete[] myStack; //delete the original pointer and free the memory
  myStack = tempStack; //make the original point to the new stack

  //Could do the following - but may not get contiguous memory block, causing
  // overwritten >data
#if 0
  int* tempStack = myStack; //create temp pointer to our current stack
  delete[] myStack; //delete the original pointer and free memory
  myStack = new int[length *= 2]; //delete not required due to new?
  myStack = tempStack;
#endif
}

Answer 1

The second block wouldn’t accomplish what you want at all.

When you do

myStack = new int[length *= 2];

then the system will return a pointer to wherever it happens to allocate the new, larger array.

You then reassign myStack to the old location (which you’ve already de-allocated!), which means you’re pointing at memory that’s not allocated (bad!) and you’ve lost the pointer to the new memory you just allocated (also bad!).

Edit: To clarify, your array will be allocated on the heap. Additionally, the (new) pointer returned by your larger array allocation (new int[foo]) will be a contiguous block of memory, like the old one, just probably in a different location. Unless you go out of bounds, don’t worry about “overwriting” memory.