理解指针的障碍是什么?可以做些什么来克服它们?

让我们假设下面使用的THouse类是这样的:

type
THouse = class
private
FName : array[0..9] of Char;
public
constructor Create(name: PChar);
end;

初始化house对象时，给构造函数的名称被复制到私有字段FName中。它被定义为固定大小的数组是有原因的。

在内存中，会有一些与房屋分配相关的开销，我将如下所示:

---[ttttNNNNNNNNNN]---
^   ^
|   |
|   +- the FName array
|
+- overhead

“tttt”区域是开销，对于各种类型的运行时和语言，通常会有更多的开销，比如8或12字节。无论存储在这个区域中的值是什么，除了内存分配器或核心系统例程之外，都不能被其他任何东西更改，否则就有可能导致程序崩溃。

分配内存

找个企业家帮你建房子，给你房子的地址。与现实世界相反，内存分配不能被告知在哪里分配，而是会找到一个有足够空间的合适位置，并将地址报告给分配的内存。

换句话说，企业家会选择地点。

THouse.Create('My house');

内存布局:

---[ttttNNNNNNNNNN]---
1234My house

保留一个带有地址的变量

把你新家的地址写在一张纸上。这份文件可以作为你房子的参考。没有这张纸，你就迷路了，找不到房子，除非你已经在里面了。

var
h: THouse;
begin
h := THouse.Create('My house');
...

内存布局:

h
v
---[ttttNNNNNNNNNN]---
1234My house

复制指针值

把地址写在一张新纸上就行了。你现在有两张纸，可以让你去同一间房子，而不是两间不同的房子。任何试图从一篇论文中跟踪地址并重新排列那所房子的家具的尝试都会使另一栋房子看起来以同样的方式被修改，除非你能明确地检测到它实际上只是一所房子。

请注意这通常是我最难向人们解释的概念，两个指针并不意味着两个对象或内存块。

var
h1, h2: THouse;
begin
h1 := THouse.Create('My house');
h2 := h1; // copies the address, not the house
...

h1
v
---[ttttNNNNNNNNNN]---
1234My house
^
h2

释放内存

拆除房子。然后，如果你愿意，你可以再用这张纸写一个新地址，或者清空它，忘记已经不存在的房子的地址。

var
h: THouse;
begin
h := THouse.Create('My house');
...
h.Free;
h := nil;

在这里，我首先建造房子，并得到它的地址。然后我对房子做了一些事情(使用它，…代码，留给读者作为练习)，然后我释放它。最后，我从变量中清除了地址。

内存布局:

h                        <--+
v                           +- before free
---[ttttNNNNNNNNNN]---          |
1234My house             <--+


h (now points nowhere)   <--+
+- after free
----------------------          | (note, memory might still
xx34My house             <--+  contain some data)

悬空指针

你告诉你的企业家毁掉房子，但你忘记从纸上擦掉地址。后来当你看到这张纸时，你已经忘记了房子已经不存在了，然后去拜访它，结果失败了(另见下面关于无效参考的部分)。

var
h: THouse;
begin
h := THouse.Create('My house');
...
h.Free;
... // forgot to clear h here
h.OpenFrontDoor; // will most likely fail

在调用.Free 可能之后使用h可以工作，但这只是纯粹的运气。最有可能的是，它会在客户的地方，在一个关键的操作中失败。

h                        <--+
v                           +- before free
---[ttttNNNNNNNNNN]---          |
1234My house             <--+


h                        <--+
v                           +- after free
----------------------          |
xx34My house             <--+

正如你所看到的，h仍然指向内存中的剩余数据，但是 因为它可能不是完整的，所以像以前一样使用它可能会失败

内存泄漏

你丢了那张纸，找不到房子。房子仍然矗立在某个地方，当你以后想建造一座新房子时，你不能重复使用那个地方。

var
h: THouse;
begin
h := THouse.Create('My house');
h := THouse.Create('My house'); // uh-oh, what happened to our first house?
...
h.Free;
h := nil;

在这里，我们用新房子的地址覆盖了h变量的内容，但旧的房子仍然存在……在某处。过了口令，就没办法到达那所房子了，它就会被留在那里。换句话说，分配的内存将一直保持分配状态，直到应用程序关闭，这时操作系统将将其删除。

第一次分配后的内存布局:

h
v
---[ttttNNNNNNNNNN]---
1234My house

第二次分配后的内存布局:

h
v
---[ttttNNNNNNNNNN]---[ttttNNNNNNNNNN]
1234My house       5678My house

获得这个方法的一个更常见的方法是忘记释放某个东西，而不是像上面那样覆盖它。在Delphi术语中，这将通过以下方法发生:

procedure OpenTheFrontDoorOfANewHouse;
var
h: THouse;
begin
h := THouse.Create('My house');
h.OpenFrontDoor;
// uh-oh, no .Free here, where does the address go?
end;

在这个方法执行之后，我们的变量中没有房子的地址存在，但是房子仍然在那里。

内存布局:

h                        <--+
v                           +- before losing pointer
---[ttttNNNNNNNNNN]---          |
1234My house             <--+


h (now points nowhere)   <--+
+- after losing pointer
---[ttttNNNNNNNNNN]---          |
1234My house             <--+

正如你所看到的，旧的数据在内存中是完整的，而不是 被内存分配器重用。分配器会跟踪它 内存区域已被使用，并且不会重用它们，除非您 自由。< / p >

释放内存但保留一个(现在无效的)引用

拆除房子，擦掉其中一张纸，但你还有另一张纸，上面写着旧地址，当你去那个地址时，你不会找到房子，但你可能会发现一些类似于废墟的东西。

也许你甚至会找到一所房子，但它不是最初给你地址的房子，因此任何试图把它当成属于你的房子都可能会失败。

有时你甚至会发现邻近的地址上有一个相当大的房子，占据了三个地址(主街1-3号)，而你的地址就在房子的中间。任何试图把大的三地址房子的那一部分当作一个单独的小房子的尝试也可能会失败。

var
h1, h2: THouse;
begin
h1 := THouse.Create('My house');
h2 := h1; // copies the address, not the house
...
h1.Free;
h1 := nil;
h2.OpenFrontDoor; // uh-oh, what happened to our house?

在这里，通过h1中的引用，房子被拆除了，而h1也被清除了，h2仍然有旧的、过时的地址。进入那座已经倒塌的房子可能有用，也可能没用。

这是上面悬浮指针的变体。查看它的内存布局。

缓冲区溢出

你往家里搬的东西多到你根本装不下，弄得邻居的房子或院子里到处都是。当隔壁房子的主人以后回家时，他会发现各种各样他认为是自己的东西。

因此，这段代码:

var
h1, h2: THouse;
begin
h1 := THouse.Create('My house');
h2 := THouse.Create('My other house somewhere');
^-----------------------^
longer than 10 characters
0123456789 <-- 10 characters

第一次分配后的内存布局:

h1
v
-----------------------[ttttNNNNNNNNNN]
5678My house

第二次分配后的内存布局:

h2                  h1
v                   v
---[ttttNNNNNNNNNN]----[ttttNNNNNNNNNN]
1234My other house somewhereouse
^---+--^
|
+- overwritten

链表

当你沿着一张纸上的地址走，你会到达一所房子，而在那所房子旁边，还有另一张纸上写着新地址，用于链条上的下一个房子，以此类推。

var
h1, h2: THouse;
begin
h1 := THouse.Create('Home');
h2 := THouse.Create('Cabin');
h1.NextHouse := h2;

在这里，我们创建了一个从我们的家到我们的小屋的链接。我们可以按照这个链，直到一个房子没有NextHouse引用，这意味着它是最后一个。要访问我们所有的房子，我们可以使用以下代码:

var
h1, h2: THouse;
h: THouse;
begin
h1 := THouse.Create('Home');
h2 := THouse.Create('Cabin');
h1.NextHouse := h2;
...
h := h1;
while h <> nil do
begin
h.LockAllDoors;
h.CloseAllWindows;
h := h.NextHouse;
end;

内存布局(在对象中添加NextHouse作为链接，用 下图中的四个LLLL):

h1                      h2
v                       v
---[ttttNNNNNNNNNNLLLL]----[ttttNNNNNNNNNNLLLL]
1234Home       +        5678Cabin      +
|        ^              |
+--------+              * (no link)

用基本术语来说，什么是内存地址?

这个内存布局:

h1                 h2
v                  v
---[ttttNNNNNNNNNN]---[ttttNNNNNNNNNN]
1234My house       5678My house

可能有这两个地址(最左边-是地址0):

• H1 = 4
• H2 = 23

这意味着我们上面的链表实际上可能是这样的:

h1 (=4)                 h2 (=28)
v                       v
---[ttttNNNNNNNNNNLLLL]----[ttttNNNNNNNNNNLLLL]
1234Home      0028      5678Cabin     0000
|        ^              |
+--------+              * (no link)

通常将“不指向任何地方”的地址存储为零地址。

用基本术语来说，什么是指针?