Why I can not delete the following pointer?

Question

int main()
{
    int x = 3;
    int* y = new int(4);
    y = &x;
    cout << y;
    delete y;
}

it shows the following error:

Error in './a.out':free(): invalid pointer:0x00007ffde8e1c0364

0x7ffde8e1c0364 Aborted

After doing `y=&x;` the pointer no longer points to some memory that was allocated with `new` but to a address from the local stack. — πάντα ῥεῖ, Aug 28 '19 at 15:58
@NathanOliver it should deallocate memory allocated to y dynamically — Amit Kumar, Aug 28 '19 at 15:59
@AmitKumar Why? You assigned `y` the address of `x`. It doesn't have the avalue of the memory it had before when you do that. — NathanOliver, Aug 28 '19 at 16:01
Dynamically allocated memory is never automatically deallocated in C++. If you want dynamic memory to be deallocated without having to manually intervene you can use standard library features that implement that behavior like `std::unique_ptr`. — François Andrieux, Aug 28 '19 at 16:03
@πάνταῥεῖ so can we say that delete can deallocate only those variable whose adress does not lie in stack .Thanks πάντα ῥεῖ — Amit Kumar, Aug 28 '19 at 16:03
@FrançoisAndrieux but what for manually deallocation of memory — Amit Kumar, Aug 28 '19 at 16:05
@AmitKumar "_so can we say that delete can deallocate only those variable whose adress does not lie in stack_" Not exactly. You can only `delete` what you `new`. — Algirdas Preidžius, Aug 28 '19 at 16:19

eerorika · Answer 1 · 2019-08-29T03:12:42.937

y cannot be deleted because it points to a an object with automatic storage after the line

y = &x;

Only an address returned by new may be deleted. If the operand of delete has some other value (such as address of an automatic object, as in the example) the behaviour of the program will be undefined.

The quoted assignment overwrites the previous value, which was the only copy of the address of the dynamic allocation. This loss of the address is called a "memory leak", since the dynamic allocation can no longer be released.

Doug Richardson · Answer 2 · 2019-08-28T16:55:53.770

6

delete destroys objects previously allocated by new, but x was not allocated by new. Your code is the same as:

int x=3;
delete &x;

See Also:

edited Aug 28 '19 at 16:55

answered Aug 28 '19 at 15:59

Doug Richardson

10,483
6
51
77

1

Technically speaking: C++ standard doesn't define "stack", or "heap", in the sense of variable storage. There are only "automatic storage duration", and "dynamic storage duration". – Algirdas Preidžius Aug 28 '19 at 16:29
@AlgirdasPreidžius there is also thread_local and static storage durations. – Doug Richardson Aug 28 '19 at 16:31
Yes? How were they relevant to this question, or you answer (as in: "_`delete` deletes from the heap, but `x` is on the stack._")? I was just stating, that the words like "stack", and "heap" mentioned in your answer, doesn't appear in C++ standard in regards to variable storage. – Algirdas Preidžius Aug 28 '19 at 16:32
You said, "there are only", but apparently I misunderstood you. – Doug Richardson Aug 28 '19 at 16:33
@AlgirdasPreidžius updated answer per your feedback – Doug Richardson Aug 28 '19 at 16:36

score 2 · Answer 3 · edited Aug 28 '19 at 16:10

2

I think you need to dereference y and assign to x.

int main()
{
    int x = 3;
    int* y = new int(4);
    *y = x;
    cout << y;
    delete y;
}

I don't get any core dumps with that.

edited Aug 28 '19 at 16:10

Guillaume Racicot

39,621
9
77
141

answered Aug 28 '19 at 16:05

JimNastic

39
4

4

This is not wrong, but I don't believe it answers the question (**Why** delete cannot be called on the pointer.) – Ben Jones Aug 28 '19 at 16:19
5

In addition to the above, minor nitpick: "_I don't get any core dumps with that._" If you don't get core dump with a specific piece of code, in several executions, of it, it doesn't, automatically, prove, that the code is free of undefined behavior. – Algirdas Preidžius Aug 28 '19 at 16:25
@BenJones Is it because 'y' is assigned a value equal to the address of 'x' ? – JimNastic Aug 28 '19 at 20:18
assigning the address `&x` to the pointer `y` is perfectly valid. The issue is that [you cannot `delete` an object allocated on the stack](https://stackoverflow.com/questions/441831/calling-delete-on-variable-allocated-on-the-stack). – Ben Jones Aug 29 '19 at 15:42

score 0 · Answer 4 · answered Aug 28 '19 at 17:22

0

When you do int x = 3;, x is stored on stack. After y = &x, pointer y points to an element in stack. When you try to delete stack memory, you get a coredump as delete works only on memory allocated on heap.

answered Aug 28 '19 at 17:22

Hemantharaju .H

94
6

score 0 · Answer 5 · answered Aug 28 '19 at 17:41

Because delete auto-storage-class is not a supported use of operator delete.

In the statement, int* y = new int(4);, you use operator new to perform an allocation.

However, in the statement, y = &x;, you change the pointer to auto int x = 3;.

An auto storage class variable is allocated by the C/C++ runtime and never by the user. This is the reason it is an error to try and delete &x;.

Why I can not delete the following pointer?

5 Answers5