为什么局部变量没有在这里销毁？

Question

I knew that when i am creating a variable inside a function, it gets destroyed immediately after the function call. Why are p[0] and p[1] still equal to 123 if the pointer x got destroyed after f's call?

#include <iostream>

using namespace std;

int *p;

void f()
{
    int *x;

    x = new int[2];

    x[0] = x[1] = 123;

    p=x;

    /// delete x;  if i delete x p[0] and p[1] are some kind of random int s;
}
int main()
{   f();

    cout<<p[0]<<p[1];

    return 0;
}

Answer 1

I knew that when i am creating a variable inside a function, it gets destroyed immediately after the function call.

Correct.

Why are p[0] and p[1] still equal to 123 if the pointer x got destroyed after f's call?

Because the array of dynamic objects pointed by the destroyed pointer x is unaffected by the pointer being destroyed.

The dynamic array is not deleted at all and you have a memory leak.

if i delete xp[0] and p[1] are some kind of random int s;

If you delete x , then p will be invalid and attempting to access through it results in undefined behaviour.

---

PS Avoid using bare owning pointers. Also avoid unnecessary dynamic allocations.

Answer 2

"Destroyed" in this case means that the variable x goes out of scope when the function ends, but it does not mean that the memory it points to is freed. What's happening here is:

1. You assign x = p , so x and p both hold the same memory address and therefore point to the same memory allocation.
2. x goes out of scope, but p doesn't, and nothing happens to the memory pointed to by p .
3. You use p to access the memory, which is perfectly valid since p has not gone out of scope and the memory it points to has not been freed.

What's crucial to understand is that the variable x and the memory you allocated are two separate things with their own lifetimes, even though x points to the memory. x going out of scope doesn't free the memory, and likewise freeing the memory doesn't cause x to go out of scope.

Answer 3

The way to "fix" your code without changing too much of it is to use std::shared_ptr<int[]> .

#include <memory>
std::shared_ptr<int[]> p;

void f()
{
    auto x = std::make_shared<int[]>(2);

    x[0] = x[1] = 123;

    p=x;
}

On the other hand, if you intend for the heap-allocated memory to be released at the end of f() , then std::unique_ptr should be used:

void f()
{
    auto x = std::make_unique<int[]>(2);

    x[0] = x[1] = 123;
}

Or, if your intent is to transfer ownership to p :

std::unique_ptr<int[]> p;

void f()
{
    auto x = std::make_unique<int[]>(2);

    x[0] = x[1] = 123;

    p=std::move(x);
}

Better yet is to avoid all of this entirely with std::vector

#include <vector>
std::vector<int> p;

void f()
{
    auto x = std::vector<int>(2);

    x[0] = x[1] = 123;

    p=std::move(x);
}