C ++悬空指针和内存泄漏

Question

我很难理解如何分辨悬空指针和内存泄漏。 关于最近的任务令我感到困惑，我有几个问题，在阅读之后，我仍然感到困惑。 我不希望有人为我做我的作业，我希望能够理解为什么它是什么，如果这是有道理的。

所以，作业：

---

鉴于声明：

int *ptrA, *ptrB;

判断下面的每个代码段是否导致内存泄漏，悬空指针或两者都没有。 画画帮忙。

1. 我猜这很好，因为ptrA已经指向内存中的某些东西，所以这个既不是悬空指针也不是内存泄漏。

ptrA = new int;
ptrB = new int;
*ptrA = 345;
ptrB = ptrA;

2. 我猜这是一个悬空指针因为345从内存中释放出来，所以ptrB指向什么都没有。

ptrA = new int;
*ptrA = 345;
ptrB = ptrA;
delete ptrA;

3. 这是我完全迷失的地方。 最后一行是否意味着指针指向另一个指针？ 不确定这会产生什么影响。

ptrA = new int;
ptrB = new int;
*ptrA = 345;
*ptrB = *ptrA;

4. 像前一个问题一样，我不确定指向指针的含义，或者我是否理解这是实现了什么。

ptrA = new int;
ptrB = new int;
*ptrA = 345;
ptrB = new int;
*ptrB = *ptrA;

5. 我知道这是一个悬垂的指针，但我不知道为什么。 是因为指针指向一个在函数完成时超出范围的局部变量？

ptrA = LocationOfAge();

函数LocationOfAge定义为：

int *LocationOfAge() {
  int age = 21;
  return &age;
}

---

感谢愿意提供帮助的任何人。

Answer 1

游戏规则：

• 对于每个new Type绘制一个框。 在框中提出一个问题（你不知道那里有什么）。
• 对于每一个delete p跨越开箱通过指向p 。
• 对于每个a = b （没有星星），从变量a到框b绘制一条线。
• 对于每个*x = y在x指向的框内写y 。
• 对于每个*x = *y读取框y的内容并将副本放在x

结果：

• 当你有一个没有变量指向它的盒子时，你有一个泄漏。
• 如果你的指针没有指向一个方框（或一个划掉的方框）你有一个悬空指针。

第一个问题：

ptrA = new int;
ptrB = new int;
*ptrA = 345;
ptrB = ptrA;

让我们一行一行：

ptrA = new int;

// Part 1 has a new so draw a box
              *********
              *   ?   *
              *********

// Part 2 assignment to variable add a line
ptrA -------> *********
              *   ?   *
              *********

ptrB = new int;

// Part 3 has a new so draw another box
ptrA -------> *********
              *   ?   *
              *********

              *********
              *   ?   *
              *********

// Part 4 assignment to variable add a line

ptrA -------> *********
              *   ?   *
              *********

ptrB -------> *********
              *   ?   *
              *********

* ptrA = 345;

ptrA -------> *********
              *  345  *
              *********

ptrB -------> *********
              *   ?   *
              *********

ptrB = ptrA;

ptrA -------> *********
        |     *  345  *
        |     *********
        |
ptrB ----     *********
              *   ?   *
              *********

好像你有一个泄漏的盒子。 即有一个没有变量指向它的框。

Answer 2

1. 我猜这很好，因为ptrA已经指向内存中的某些东西，所以这个既不是悬空指针也不是内存泄漏。

是的，但现在ptrB指向它，你无法释放ptrB之前指出的东西。

这是一个泄漏。

2. 我猜这是一个悬空指针因为345从内存中释放出来，所以ptrB指向什么都没有。

正确。

3. 最后一行是否意味着指针指向另一个指针？

不，它给出了< ptrB指向的东西> < ptrA指向的东西>的值。 所涉及的指针没有变化，只有int赋值。

4. 像前一个问题一样，我不确定指向指针的含义，或者我是否理解这是实现了什么。

第二个new int被泄露，因为过去指向它的东西（ ptrB ）现在指向第三个 new int而前者不能再被释放。

5. 我知道这是一个悬垂的指针，但我不知道为什么。 是因为指针指向一个在函数完成时超出范围的局部变量？

是。

Answer 3

为了防止完成所有作业，你的第一个假设是错误的。

1. ptrA = new int;
2. ptrB = new int;
3. *ptrA = 345;
4. ptrB = ptrA;

在第1行中，ptrA创建一个新的整数（分配字节），在第2行中，ptrB分配字节。 比在3中，1中分配的内存被填充，这是可以的。 但是，在第4行中，ptrB被地址3覆盖，这意味着ptrB的原始地址不再可达。 因此存在内存泄漏，因为不再能够访问由第2行为整数PtrB分配的字节，因为没有指针指向它。

如果你写一个绘图，通过使用箭头指针和一个带有？的框，会容易得多？ 填写时的声明和特定值。所以它看起来像：

1. ptrA -> [  ?  ]
2. ptrA -> [  ?  ], ptrB -> [ ? ]
3. ptrA -> [ 345 ], ptrB -> [ ? ]
4. ptrA -> [ 345 ] <- ptrB, [ ? ]

如你所见，最后一个方框[？ ]没有指向它的指针。

Answer 4

我们一次提出一个问题。

ptrA = new int;
ptrB = new int;
*ptrA = 345;
ptrB = ptrA;

这是一个内存泄漏。 为什么？ 因为首先没有delete 。 其次，当你做ptrB = ptrA; ，实际上没有办法为之前由ptrB指向的对象调用delete 。

ptrA = new int;
*ptrA = 345;
ptrB = ptrA;
delete ptrA;

这是悬空指针的一个例子。 一旦在ptrA上调用delete ，ptrA指向的对象就会被释放。 因此，ptrB指向一个解除分配的位置，其行为未定义。 所以，悬空指针！

ptrA = new int;
ptrB = new int;
*ptrA = 345;
*ptrB = *ptrA;

这里只是因为我们没有调用delete而存在内存泄漏。 我们正在做的是创建两个对象，分别由ptrA和ptrB指向，两个对象的值都为345.它们仍然在堆中保留空间。 但是为什么两者的价值都是345？ 简单。

当你做*ptrA = 345; ，这意味着ptrA指向的对象的值应该设置为345。

当你做*ptrB = *ptrA; ，这意味着ptrB指向的对象的值应该赋值为ptrA指向的对象的值。

这是解除引用运算符的简单功能。

ptrA = new int;
ptrB = new int;
*ptrA = 345;
ptrB = new int;
*ptrB = *ptrA;

这与第一个类似。 在第2行中，ptrB指向动态分配的对象。 执行第4行后，ptrB指向全新的对象。 因此，没有办法解除分配在第2行分配内存的对象。所以，内存泄漏！

int *LocationOfAge() {
    int age = 21;
    return &age;
}

在这里， age是一个局部变量，一旦函数结束就会死掉。 因此，任何指向该局部变量的指针都会导致未定义的行为。 所以，悬空指针！