4 
int *ip = new int[10];
for (int i = 0; i<10; i++)
    *(ip+i) = i;

myfun(ip);  // assume that myfun takes an argument of
            //   type int* and returns no result

delete [] ip;

The above code is a small segment of a test function that I am trying to use to learn about the stack and the heap.

I am not fully sure what the correct sequence is.

This is what I have thus far:

  • When the pointer ip is created it points to a new int array of size 10 created on the heap due to to the "new" declaration.
  • 0-9 is added to the array from 0-9.
  • The pointer is now passed through to myfun which means that myfun has a pointer that points to the same memory space on the heap.
  • The delete []ip; removes the memory allocated on the heap to the ip pointer. The pointer that got passed through to myFun now points to nothing.
  • Once the function has finished the ip variable is deleted as it is only local to the function.

Would someone be able to clarify if I am correct or not and correct me where I went wrong? Also if I attempted to carry on using ip after that would it just point to nothing ?

Improve this question
12
  • 1
    stack variables are not literally deleted, stack top (esp) simply goes down. the next called function will move it up again, and so on so forth Commented May 18, 2015 at 9:27
  • 2
    Conceptually the variable is destroyed, practically this is done by returning the stack pointer to where it was before the function was called. Commented May 18, 2015 at 9:31
  • 4
    "The pointer that got passed through to myFun now points to nothing." - that's a bit vague... the pointer will continue to hold the same memory address, but it won't be valid to dereference the pointer until after it's assigned a still-valid pointer value. Commented May 18, 2015 at 9:31
  • 1
    "potentially accessible" is a slippery slope. It's best to assume that trying to access that memory will give you nasal demons, even if the data there might be valid. Commented May 18, 2015 at 9:35
  • 2
    Also, new allocates memory on the free-store rather than the heap, but that is mostly a conceptual difference. Commented May 18, 2015 at 9:36

3 Answers 3

Reset to default
3

The sequence is correct except one point:

The delete []ip; removes the memory allocated on the heap to the ip pointer. The pointer that got passed through to myFun now points to nothing.

The pointer doesn't point to 'nothing' (i.e. isn't set to nullptr or 0 after freeing the memory). It just points to the same location which is now freed memory (i.e. memory marked as freed by the application and that can no longer be safely accessed). Accessing memory through that pointer would trigger undefined behavior.

One last notice: myfun might take the pointer by value or by reference. There are differences but your sentence would still be valid.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

I believe everything is correct, I have the following minor remark regarding the following bullet point;

  • The delete []ip; removes the memory allocated on the heap to the ip pointer. The pointer that got passed through to myFun now points to nothing.

It is not guaranteed that the pointer points to "nothing", in general it is recommended (see clarification in comment below this answer) that after your delete call, you initialize the pointer to NULL, i.e. ip = NULL in order to ensure the pointer points to nothing (instead of pointing to unallocated memory).

Improve this answer

1 Comment

"in general it is recommended" - I'd recommend not doing this if the pointer's about to end its lifetime, e.g. because it's in a scope that's about to exit, or it's been deleted inside a destructor... in such situations, to set it to NULL would falsely suggest some significance/utility and be needlessly verbose.
1

Everything is correct. But beware that calling delete doesn't delete anything but free the memory previously allocated, which means that your pointer contains the address that you mustn't use (dereferencing a free chunk of memory leeads to undefined behavior). The same for your stack variable, the memory associated to your local variable is not destroyed but released, so you mustn't try to use it. stack and heap are just two ways of memory management with two basic same operation (alloc/free).

So technically you can't say that your pointer points to anything, but it points to something that you are not authorized to use.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.