在C ++中删除指针

背景信息：我想把指针包裹住，几个星期前我们刚在学校看到它们，今天练习的时候我遇到了傻子吗？问题，对您来说可能非常简单，但是我几乎没有编程经验。

我已经在SO中看到了很多有关删除指针的问题，但它们似乎都与删除类有关，而不是与“简单”指针（或任何适当的术语）有关，这是我正在尝试的代码跑：

#include <iostream>;

using namespace std;

int main() {
  int myVar,
      *myPointer;

  myVar = 8;
  myPointer = &myVar;

  cout << "delete-ing pointers " << endl;
  cout << "Memory address: " << myPointer << endl;

  // Seems I can't *just* delete it, as it triggers an error 
  delete myPointer;
  cout << "myPointer: " << myPointer << endl;
  // Error: a.out(14399) malloc: *** error for object 0x7fff61e537f4:
  // pointer being freed was not allocated
  // *** set a breakpoint in malloc_error_break to debug
  // Abort trap: 6

  // Using the new keyword befor deleting it works, but
  // does it really frees up the space? 
  myPointer = new int;
  delete myPointer;
  cout << "myPointer: " << myPointer << endl;
  // myPointer continues to store a memory address.

  // Using NULL before deleting it, seems to work. 
  myPointer = NULL;
  delete myPointer;
  cout << "myPointer: " << myPointer << endl;
  // myPointer returns 0.

}

所以我的问题是：

1. 为什么第一种情况不起作用？似乎最直接的使用方式是使用和删除指针？该错误表明未分配内存，但'cout'返回了一个地址。
2. 在第二个示例中，未触发错误，但是对myPointer的值进行计算仍然返回内存地址？
3. ＃3真的有效吗？似乎对我有用，指针不再存储地址，这是删除指针的正确方法吗？

很长的问题，很抱歉，想让这个问题尽可能清楚，还要重申，我几乎没有编程经验，所以如果有人可以使用外行的术语回答这个问题，将不胜感激！

1和2

myVar = 8; //not dynamically allocated. Can't call delete on it.
myPointer = new int; //dynamically allocated, can call delete on it.

第一个变量分配在堆栈上。您只能使用new运算符在动态分配的内存（在堆上）上调用delete 。

3。

  myPointer = NULL;
  delete myPointer;

上面什么也没做。您没有释放任何东西，因为指针指向NULL。

不应执行以下操作：

myPointer = new int;
myPointer = NULL; //leaked memory, no pointer to above int
delete myPointer; //no point at all

您将其指向NULL，留下了泄漏的内存（您分配的新int）。您应该释放所指向的内存。无法再访问已分配的方法new int，因此会导致内存泄漏。

正确的方法：

myPointer = new int;
delete myPointer; //freed memory
myPointer = NULL; //pointed dangling ptr to NULL

更好的方法：

如果您使用的是C ++，请不要使用原始指针。使用智能指针代替它可以为您处理这些事情，而开销很小。C ++ 11附带了几个。

我相信您还没有完全了解指针的工作方式。
当您有一个指向某些内存的指针时，您必须了解三件事：
-指针（内存）有“所指向的内容”
-该内存地址
-并非所有指针都需要删除其内存：您只需需要删除动态分配的内存（使用的new运算符）。

想像：

int *ptr = new int; 
// ptr has the address of the memory.
// at this point, the actual memory doesn't have anything.
*ptr = 8;
// you're assigning the integer 8 into that memory.
delete ptr;
// you are only deleting the memory.
// at this point the pointer still has the same memory address (as you could
//   notice from your 2nd test) but what inside that memory is gone!

你什么时候做

ptr = NULL;
// you didn't delete the memory
// you're only saying that this pointer is now pointing to "nowhere".
// the memory that was pointed by this pointer is now lost.

C ++允许您尝试指向delete一个指向的指针，null但是它实际上并没有做任何事情，只是没有给出任何错误。

指针与普通变量相似，因为您不需要删除它们。在函数执行结束和/或程序结束时将它们从内存中删除。

但是，您可以使用指针分配内存的“块”，例如：

int *some_integers = new int[20000]

这将为20000整数分配内存空间。之所以有用，是因为堆栈的大小有限，您可能想在没有堆栈溢出错误的情况下处理大量的“ ints”。

每当调用new时，都应在程序末尾“删除”，因为否则会发生内存泄漏，并且某些分配的内存空间将永远不会返回供其他程序使用。去做这个：

delete [] some_integers;

希望能有所帮助。

在C ++中有一条规则，对于每个新规则都有一个delete。

1. 为什么第一种情况不起作用？似乎最直接的使用方式是使用和删除指针？该错误表明未分配内存，但'cout'返回了一个地址。

从来没有叫过。因此，cout打印的地址是myVar的内存位置的地址，或者在这种情况下是分配给myPointer的值。通过写：

myPointer = &myVar;

你说：

myPointer = myVar中数据存储的地址

2. 在第二个示例中，未触发错误，但是对myPointer的值进行计算仍然返回内存地址？

它返回一个指向已删除的存储位置的地址。因为首先创建指针并将其值分配给myPointer，然后再删除它，然后再打印就可以了。因此，除非您为myPointer分配另一个值，否则删除的地址将保留。

3. ＃3真的有效吗？似乎对我有用，指针不再存储地址，这是删除指针的正确方法吗？

NULL等于0，则删除0，因此不删除任何内容。逻辑上说它打印0是因为您这样做了：

myPointer = NULL;

等于：

myPointer = 0;

1. 您试图删除分配在堆栈上的变量。你不能做这个
2. 删除指针实际上并不会破坏指针，只是将占用的内存返回给OS。您可以访问它，直到将内存用于其他变量或进行其他操作为止。因此，优良作法是在删除后将指针设置为NULL（0）。
3. 删除NULL指针不会删除任何内容。

int value, *ptr;

value = 8;
ptr = &value;
// ptr points to value, which lives on a stack frame.
// you are not responsible for managing its lifetime.

ptr = new int;
delete ptr;
// yes this is the normal way to manage the lifetime of
// dynamically allocated memory, you new'ed it, you delete it.

ptr = nullptr;
delete ptr;
// this is illogical, essentially you are saying delete nothing.