为什么这个程序可以编译？ 它应该不会出错，因为我删除了同样的东西两次

Question

This code runs perfectly fine and does not give any error which I think it should as I am deleting the same thing twice.

#include<iostream>
int main(){
        int* var1 = new int;
        int* var2 = var1;
        *var1 = 10;
        *var2 = 15;
        std::cout << var1 << std::endl;
        std::cout<<var2<<std::endl;
        delete var1;
        delete var2;
        std::cout<<"Hello World";
return 0;}

Answer 1

The variables var1 and var2 are stack variables, but the addresses they hold are not. The address that a pointer holds might point to garbage, to the stack, to the heap or to the data segment. Neither would be automatically deleted when the pointer is dead.

In your first post of the code it seemed that you assume a local pointer variable is dead, by getting out of scope and frees the address that it holds. This is not the case. This is why heap allocation requires manual freeing.

But then you posted the edit with two calls to delete .

In your program, var1 and var2 point to the same place on the heap, which is perfectly fine.

Then their content is populated with different values, which is also ok. Each assignment overrides the previous as it is written to the same place in memory.

As for the two calls to delete on the same address, the compiler doesn't follow what your code does. It only compiles the code and checks for specific errors that the specification required it to check.

The compiler in most cases cannot actually notice if an address is deleted twice, so it would probably not even try to give a warning, even if you delete the exact same variable twice, consequently. For example, both gcc and clang doesn't raise any warning for the following code, which is fine, they are not supposed to:

int main() {
    int* ptr = new int;
    delete ptr;
    delete ptr;
}

Static analysis tools may analyze this and point at the problematic code, but it is not the job of the compiler.