堆栈内存溢出
  繁体   English   中英

理解指针的障碍是什么？如何克服这些障碍？ [关闭]

[英]What are the barriers to understanding pointers and what can be done to overcome them? [closed]

 原文  2008-08-08 06:17:51  3   28    c++/ c/ pointers

问题描述

为什么指针对于 C 或 C++ 的许多新的甚至老的大学水平的学生来说是一个如此混乱的主要因素？ 是否有任何工具或思维过程可以帮助您了解指针在变量、函数和其他级别上的工作方式？

有哪些好的做法可以让某人达到“啊哈，我明白了”的水平，而又不会让他们陷入整体概念的泥潭？ 基本上，像场景一样演练。

28 个解决方案

解决方案1
 751 已采纳  

指针是一个概念，许多人一开始可能会感到困惑，尤其是在复制指针值并仍然引用相同的内存块时。

我发现最好的类比是将指针视为一张纸，上面有房屋地址，而它引用的内存块则是实际房屋。 因此可以很容易地解释各种操作。

我在下面添加了一些 Delphi 代码，并在适当的地方添加了一些注释。 我选择了 Delphi，因为我的其他主要编程语言 C# 不会以相同的方式表现出内存泄漏等问题。

如果你只想学习指针的高级概念，那么你应该忽略下面解释中标有“内存布局”的部分。 它们旨在举例说明操作后内存的外观，但它们本质上更底层。 然而，为了准确地解释缓冲区溢出的实际工作原理，我添加了这些图表很重要。

免责声明：出于所有意图和目的，此解释和示例内存布局已大大简化。 如果您需要在低级别基础上处理内存，则需要了解更多开销和更多细节。 但是，对于解释内存和指针的意图，它已经足够准确了。

让我们假设下面使用的 THouse 类如下所示：

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

当您初始化房屋对象时，给构造函数的名称被复制到私有字段 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             <--+

如您所见，旧数据在内存中完好无损，不会被内存分配器重用。 分配器会跟踪哪些内存区域已被使用，除非您释放它，否则不会重用它们。

释放内存但保留（现在无效）引用

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

也许你甚至会找到一所房子，但它不是你最初得到地址的房子，因此任何试图使用它好像它属于你的尝试都可能会失败。

有时您甚至可能会发现相邻地址上设置了一个相当大的房子，占据了三个地址（Main Street 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

最常导致崩溃的部分是当您覆盖存储的数据中真正不应随机更改的重要部分时。 例如，就程序崩溃而言，更改 h1-house 的部分名称可能不是问题，但是当您尝试使用损坏的对象时，覆盖对象的开销很可能会导致崩溃覆盖存储到对象中其他对象的链接。

链表

当你跟随一张纸上的地址时，你会到达一所房子，在那所房子里还有另一张纸，上面有一个新地址，链中的下一个房子，依此类推。

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)

基本上，什么是内存地址？

内存地址在基本术语中只是一个数字。 如果您将内存视为一个大字节数组，那么第一个字节的地址为 0，下一个字节的地址为 1，以此类推。 这是简化的，但足够好。

所以这个内存布局：

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)

通常将“无处指向”的地址存储为零地址。

在基本术语中，什么是指针？

指针只是一个保存内存地址的变量。 您通常可以要求编程语言给您它的编号，但大多数编程语言和运行时都试图隐藏下面有一个数字的事实，仅仅因为数字本身对您没有任何意义。 最好将指针视为一个黑匣子，即。 你并不真正知道或关心它是如何实际实现的，只要它有效。

解决方案2
 155  

在我的第一节 Comp Sci 课上，我们做了以下练习。 没错，这是一个大约有200名学生在里面的演讲厅……

教授在黑板上写道： int john;

约翰站起来

教授写道： int *sally = &john;

莎莉站起来，指着约翰

教授： int *bill = sally;

比尔站起来，指着约翰

教授： int sam;

山姆站起来

教授： bill = &sam;

比尔现在指向山姆。

我想你应该已经明白了。 我想我们花了大约一个小时来做​​这件事，直到我们了解了指针分配的基础知识。

解决方案3
 127  

我发现一个有助于解释指针的类比是超链接。 大多数人都可以理解网页上的链接“指向”互联网上的另一个页面，如果您可以复制并粘贴该超链接，那么它们都将指向同一个原始网页。 如果您去编辑那个原始页面，然后按照这些链接（指针）中的任何一个，您将获得新的更新页面。

解决方案4
 49  

指针似乎让这么多人感到困惑的原因是，它们大多没有或很少有计算机体系结构的背景。 由于许多人似乎不了解计算机（机器）的实际实现方式 - 在 C/C++ 中工作似乎很陌生。

一个练习是让他们实现一个简单的基于字节码的虚拟机（在他们选择的任何语言中，python 都非常适合），其指令集专注于指针操作（加载、存储、直接/间接寻址）。 然后让他们为该指令集编写简单的程序。

任何需要比简单加法稍微多一点的东西都将涉及指针，他们肯定会得到它。

解决方案5
 27  

为什么指针是 C/C++ 语言中许多新的甚至老的大学水平学生的困惑的主要因素？

值占位符的概念 - 变量 - 映射到我们在学校教授的东西 - 代数。 如果不了解计算机中内存的物理布局，您就无法绘制现有的并行结构，并且在处理低级事物之前，没有人会考虑这种事情 - 在 C/C++/字节通信级别.

是否有任何工具或思维过程可以帮助您了解指针在变量、函数和其他级别上的工作方式？

地址框。 我记得当我学习将 BASIC 编程到微型计算机中时，有这些漂亮的书，里面有游戏，有时你必须将值插入特定的地址。 他们有一堆盒子的图片，用 0, 1, 2 递增地标记......并解释说这些盒子只能放一个小东西（一个字节），而且有很多 - 一些计算机竟然有65535个！ 他们挨着挨着，都有一个地址。

有哪些好的做法可以让某人达到“啊哈，我明白了”的水平，而又不会让他们陷入整体概念的泥潭？ 基本上，像场景一样演练。

为了演练？ 创建一个结构：

struct {
char a;
char b;
char c;
char d;
} mystruct;
mystruct.a = 'r';
mystruct.b = 's';
mystruct.c = 't';
mystruct.d = 'u';

char* my_pointer;
my_pointer = &mystruct.b;
cout << 'Start: my_pointer = ' << *my_pointer << endl;
my_pointer++;
cout << 'After: my_pointer = ' << *my_pointer << endl;
my_pointer = &mystruct.a;
cout << 'Then: my_pointer = ' << *my_pointer << endl;
my_pointer = my_pointer + 3;
cout << 'End: my_pointer = ' << *my_pointer << endl;

与上面相同的示例，除了在 C 中：

// Same example as above, except in C:
struct {
    char a;
    char b;
    char c;
    char d;
} mystruct;

mystruct.a = 'r';
mystruct.b = 's';
mystruct.c = 't';
mystruct.d = 'u';

char* my_pointer;
my_pointer = &mystruct.b;

printf("Start: my_pointer = %c\n", *my_pointer);
my_pointer++;
printf("After: my_pointer = %c\n", *my_pointer);
my_pointer = &mystruct.a;
printf("Then: my_pointer = %c\n", *my_pointer);
my_pointer = my_pointer + 3;
printf("End: my_pointer = %c\n", *my_pointer);

输出：

Start: my_pointer = s
After: my_pointer = t
Then: my_pointer = r
End: my_pointer = u

也许这通过示例解释了一些基础知识？

解决方案6
 24  

起初我很难理解指针的原因是，很多解释都包含了很多关于通过引用传递的废话。 所有这些都会混淆问题。 当您使用指针参数时，您仍然是按值传递； 但该值恰好是一个地址，而不是一个整数。

其他人已经链接到本教程，但我可以强调我开始理解指针的那一刻：

C 中指针和数组的教程：第 3 章 - 指针和字符串

int puts(const char *s);

目前，忽略const. 传递给puts()的参数是一个指针，即指针的值（因为 C 中的所有参数都是按值传递的），而指针的值是它指向的地址，或者简单地说，是一个地址. 因此，当我们写puts(strA); 正如我们所见，我们正在传递 strA[0] 的地址。

读到这些文字的瞬间，乌云散开，一束阳光用指针式的理解笼罩着我。

即使您是 VB .NET 或 C# 开发人员（就像我一样）并且从不使用不安全代码，仍然值得了解指针的工作原理，否则您将无法了解对象引用的工作原理。 然后你会有一个常见但错误的概念，即将对象引用传递给方法会复制对象。

解决方案7
 19  

我发现 Ted Jensen 的“C 中的指针和数组教程”是学习指针的绝佳资源。 它分为 10 课，从解释什么是指针（以及它们的用途）开始，到函数指针结束。 http://web.archive.org/web/20181011221220/http://home.netcom.com:80/~tjensen/ptr/cpoint.htm

从那里开始，Beej 的网络编程指南讲授了 Unix 套接字 API，您可以从中开始做真正有趣的事情。 http://beej.us/guide/bgnet/

解决方案8
 12  

指针的复杂性超出了我们可以轻松教授的范围。 让学生互相指指点点和使用写有住址的纸片都是很好的学习工具。 他们在介绍基本概念方面做得很好。 事实上，学习基本概念对于成功使用指针至关重要。 但是，在生产代码中，通常会遇到比这些简单演示所能封装的更复杂的场景。

我参与过一些系统，在这些系统中，我们的结构指向其他结构，指向其他结构。 其中一些结构还包含嵌入式结构（而不​​是指向其他结构的指针）。 这就是指针变得非常混乱的地方。 如果您有多个间接级别，并且您开始以这样的代码结束：

widget->wazzle.fizzle = fazzle.foozle->wazzle;

它会很快变得混乱（想象一下更多的行，以及可能更多的级别）。 放入指针数组和节点到节点指针（树、链表），情况会变得更糟。 我见过一些非常优秀的开发人员一旦开始在这样的系统上工作就会迷失方向，即使是非常了解基础知识的开发人员。

指针的复杂结构也不一定表示编码不佳（尽管它们可以）。 组合是良好的面向对象编程的重要组成部分，在具有原始指针的语言中，它不可避免地会导致多层间接。 此外，系统通常需要使用第三方库，其结构在风格或技术上彼此不匹配。 在这样的情况下，复杂性自然会出现（当然，我们应该尽可能地与之抗争）。

我认为大学可以帮助学生学习指针的最好方法是使用好的演示，结合需要使用指针的项目。 一个困难的项目比一千个演示更有助于指针理解。 演示可以让你肤浅的理解，但要深入掌握指针，你必须真正使用它们。

解决方案9
 10  

我想我会在这个列表中添加一个类比，当我作为计算机科学导师解释指针时（回到当​​天），我发现它非常有帮助； 首先，让我们：

设置舞台：

考虑一个有 3 个车位的停车场，这些车位已编号：

-------------------
|     |     |     |
|  1  |  2  |  3  |
|     |     |     |

在某种程度上，这就像内存位置，它们是连续的和连续的......有点像一个数组。 现在里面没有汽车，所以它就像一个空数组（ parking_lot[3] = {0} ）。

添加数据

一个停车场永远不会空着很久……如果是这样，那将毫无意义，也没有人会建造任何停车场。 因此，假设随着时间的推移，场地上有 3 辆汽车，一辆蓝色汽车、一辆红色汽车和一辆绿色汽车：

   1     2     3
-------------------
| o=o | o=o | o=o |
| |B| | |R| | |G| |
| o-o | o-o | o-o |

这些汽车都是相同的类型（汽车），所以一种思考方式是我们的汽车是某种数据（比如int ），但它们具有不同的值（ blue 、 red 、 green ；这可能是一个颜色enum ）

输入指针

现在，如果我带你到这个停车场，让你给我找一辆蓝色的车，你伸出一根手指，用它指向第 1 点的一辆蓝色的车。这就像拿一个指针，并将它分配给一个内存地址( int *finger = parking_lot )

你的手指（指针）不是我问题的答案。 看着你的手指会告诉我什么，但如果我看你在哪里手指指向（解引用指针），我能找到我一直在寻找汽车（数据）。

重新分配指针

现在我可以让你找一辆红色的车代替，你可以将你的手指重定向到一辆新车。 现在你的指针（和以前一样）正在向我显示相同类型（汽车）的新数据（可以找到红色汽车的停车位）。

指针在物理上没有改变，它仍然是你的手指，只是它显示给我的数据改变了。 （“停车位”地址）

双指针（或指向指针的指针）

这也适用于多个指针。 我可以问指针在哪里，它指向红色汽车，你可以用另一只手，用一根手指指向第一根手指。 （这就像int **finger_two = &finger ）

现在，如果我想知道蓝色汽车在哪里，我可以按照第一根手指的方向到第二根手指，到汽车（数据）。

悬空的指针

现在让我们假设你感觉非常像一座雕像，你想无限期地握着你的手指着那辆红色的汽车。 如果那辆红色的车开走了怎么办？

   1     2     3
-------------------
| o=o |     | o=o |
| |B| |     | |G| |
| o-o |     | o-o |

你的指针仍然指向红色赛车，但不再是哪里。 假设一辆新车停在那里……一辆橙色汽车。 现在如果我再问你，“红色汽车在哪里”，你仍然指着那里，但现在你错了。 那不是红色的车，那是橙色的。

指针运算

好的，所以你仍然指着第二个停车位（现在被橙色汽车占用）

   1     2     3
-------------------
| o=o | o=o | o=o |
| |B| | |O| | |G| |
| o-o | o-o | o-o |

好吧，我现在有一个新问题……我想知道下一个停车位的汽车颜色。 您可以看到您指向的是点 2，因此您只需添加 1 并指向下一个点。 ( finger+1 )，既然我想知道那里的数据是什么，你必须检查那个点（不仅仅是手指），这样你就可以尊重指针（ *(finger+1) ）看到有一个绿色那里的汽车（该位置的数据）

解决方案10
 10  

我不认为指针作为一个概念特别棘手——大多数学生的心智模型映射到这样的东西，一些快速的方框草图会有所帮助。

困难，至少我在过去经历过并看到其他人处理过的困难在于，C/C++ 中的指针管理可能会不必要地复杂化。

解决方案11
 9  

带有一组良好图表的教程示例对理解指针有很大帮助。

Joel Spolsky 在他的Guerrilla Guide to Interviewing文章中对理解指针提出了一些很好的观点：

出于某种原因，大多数人似乎天生就没有理解指针的大脑部分。 这是一种天赋，而不是技能——它需要一种复杂的双重间接思维形式，有些人做不到。

解决方案12
 8  

我认为理解指针的主要障碍是糟糕的老师。

几乎每个人都被教导关于指针的谎言：它们只不过是内存地址，或者它们允许您指向任意位置。

当然，它们难以理解，危险且半魔法。

没有一个是真的。 指针实际上是相当简单的概念，只要你坚持 C++ 语言对它们的看法，并且不要给它们灌输“通常”在实践中起作用但仍然不受语言保证的属性，因此不是指针实际概念的一部分。

几个月前，我试图在这篇博文中写下对此的解释——希望它能对某人有所帮助。

（注意，在有人对我迂腐之前，是的，C++ 标准确实说指针代表内存地址。但它并没有说“指针是内存地址，除了内存地址什么也没有，并且可以与内存互换使用或考虑地址”。区别很重要）

解决方案13
 8  

指针的问题不在于概念。 这是所涉及的执行和语言。 当教师认为难的是指针的概念，而不是行话或 C 和 C++ 对概念造成的令人费解的混乱时，会产生额外的混淆。 因此，大量的努力都用于解释这个概念（就像在这个问题的公认答案中一样），而且几乎只是浪费在像我这样的人身上，因为我已经理解了所有这些。 它只是解释了问题的错误部分。

为了让您了解我来自哪里，我是一个非常了解指针的人，并且我可以在汇编语言中胜任地使用它们。 因为在汇编语言中它们不被称为指针。 它们被称为地址。 当谈到在 C 中编程和使用指针时，我犯了很多错误并且非常困惑。 我还没有解决这个问题。 让我给你举个例子。

当 api 说：

int doIt(char *buffer )
//*buffer is a pointer to the buffer

它想要什么？

它可能想要：

表示缓冲区地址的数字

（为此，我是说doIt(mybuffer)还是doIt(*myBuffer) ？）

表示缓冲区地址的数字

（是doIt(&mybuffer)还是doIt(mybuffer)或doIt(*mybuffer) ？）

一个数字，表示地址到地址到缓冲区的地址

（也许那是doIt(&mybuffer) 。还是doIt(&&mybuffer) ？甚至是doIt(&&&mybuffer) ）

等等，所涉及的语言并没有说清楚，因为它涉及“指针”和“引用”这两个词对我来说没有“x 保存 y 的地址”和“这个函数需要一个到 y 的地址”。 答案还取决于“mybuffer”到底是从什么开始的，以及 doIt 打算用它做什么。 该语言不支持在实践中遇到的嵌套级别。 就像我必须将“指针”传递给创建新缓冲区的函数一样，它会修改指针以指向缓冲区的新位置。 它是真的想要指针，还是指向指针的指针，所以它知道去哪里修改指针的内容。 大多数时候我只需要猜测“指针”是什么意思，而大多数时候我错了，不管我在猜测方面有多少经验。

“指针”太重了。 指针是指向值的地址吗？ 或者它是一个保存值的地址的变量。 当一个函数需要一个指针时，它是需要指针变量保存的地址，还是需要指针变量的地址？ 我糊涂了。

解决方案14
 5  

我认为让指针难以学习的原因是，在指针之前，您对“在此内存位置是一组表示 int、double、字符等的位”的想法感到满意。

当您第一次看到指针时，您并没有真正了解该内存位置的内容。 “什么意思，里面有地址？”

我不同意“你要么得到它们要么不得到”的观点。

当您开始寻找它们的真正用途时（例如不将大型结构传递给函数），它们会变得更容易理解。

解决方案15
 5  

它如此难以理解的原因不是因为它是一个困难的概念，而是因为语法不一致。

   int *mypointer;

您首先了解到变量创建的最左侧部分定义了变量的类型。 指针声明在 C 和 C++ 中不是这样工作的。 相反，他们说变量指向左侧的类型。 在这种情况下： * mypointer指向一个 int。

直到我尝试在 C# 中使用它们（不安全），我才完全掌握指针，它们以完全相同的方式工作，但具有逻辑和一致的语法。 指针本身就是一种类型。 这里mypointer是一个指向 int 的指针。

  int* mypointer;

甚至不要让我开始使用函数指针......

解决方案16
 5  

当我只知道 C++ 时，我可以使用指针。 我有点知道在某些情况下该做什么，以及从试验/错误中不该做什么。 但是让我完全理解的是汇编语言。 如果您使用您编写的汇编语言程序进行一些严肃的指令级调试，您应该能够理解很多东西。

解决方案17
 4  

我喜欢房子地址的比喻，但我一直认为地址是邮箱本身。 通过这种方式，您可以形象化取消引用指针（打开邮箱）的概念。

例如遵循一个链表：1）从你的论文开始 2）转到论文上的地址 3）打开邮箱找到一张新的纸，上面有下一个地址

在线性链表中，最后一个邮箱中没有任何内容（列表末尾）。 在循环链表中，最后一个邮箱包含第一个邮箱的地址。

请注意，第 3 步是取消引用发生的地方，也是当地址无效时您将崩溃或出错的地方。 假设你可以走到一个无效地址的邮箱，想象那里有一个黑洞或什么东西可以把世界翻个底朝天:)

解决方案18
 3  

我认为人们对它有困难的主要原因是它通常没有以有趣和引人入胜的方式教授。 我想看到一位讲师从人群中抽取 10 名志愿者，并给他们每人一个 1 米的直尺，让他们以某种形式站立并用直尺相互指向。 然后通过移动人们（以及他们将标尺指向何处）来显示指针算术。 这将是一种简单但有效（最重要的是令人难忘）的方式来展示概念，而不会陷入机制中。

一旦你接触到 C 和 C++，对某些人来说似乎变得更难了。 我不确定这是因为他们最终将他们没有正确掌握的理论付诸实践，还是因为在这些语言中指针操作本质上更难。 我不太记得我自己的转换，但我知道Pascal 中的指针，然后转移到 C 并完全迷失了。

解决方案19
 2  

我喜欢用数组和索引来解释它——人们可能不熟悉指针，但他们通常知道索引是什么。

所以我说想象一下 RAM 是一个数组（而你只有 10 字节的 RAM）：

unsigned char RAM[10] = { 10, 14, 4, 3, 2, 1, 20, 19, 50, 9 };

然后，指向变量的指针实际上只是 RAM 中该变量（的第一个字节）的索引。

因此，如果您有一个指针/索引unsigned char index = 2 ，那么该值显然是第三个元素或数字 4。指向指针的指针是您获取该数字并将其用作索引本身的位置，例如RAM[RAM[index]] 。

我会在一张纸列表上绘制一个数组，然后用它来显示许多指向同一内存的指针、指针运算、指向指针的指针等内容。

解决方案20
 2  

我不认为指针本身令人困惑。 大多数人都能理解这个概念。 现在您可以考虑多少个指针或您对多少个间接级别感到满意。 不需要太多就可以将人置于边缘。 事实上，它们可能会被程序中的错误意外更改，这也会使它们在代码出现问题时很难调试。

解决方案21
 2  

我认为这实际上可能是一个语法问题。 指针的 C/C++ 语法似乎不一致，而且比它需要的更复杂。

具有讽刺意味的是，实际上帮助我理解指针的是在 c++标准模板库中遇到迭代器的概念。 这很讽刺，因为我只能假设迭代器被认为是指针的泛化。

有时，除非您学会忽略树木，否则您将无法看到森林。

解决方案22
 2  

混淆来自“指针”概念中混合在一起的多个抽象层。 程序员不会对 Java/Python 中的普通引用感到困惑，但指针的不同之处在于它们暴露了底层内存架构的特征。

干净地分离抽象层是一个很好的原则，而指针不会这样做。

解决方案23
 1  

上面的一些答案断言“指针并不难”，但并没有直接解决“指针很难！”的问题。 来自。 几年前，我辅导了第一年的 CS 学生（只有一年，因为我显然很擅长），我很清楚指针的想法并不难。 难的是理解为什么以及何时需要指针。

我认为你不能把这个问题——为什么以及何时使用指针——与解释更广泛的软件工程问题分开。 为什么每个变量都不应该是全局变量，为什么应该将类似的代码分解为函数（也就是说，得到这个，使用指针将它们的行为专门化到它们的调用站点）。

解决方案24
 1  

邮政信箱号码。

这是一条信息，可让您访问其他内容。

（如果你对邮政信箱号码进行算术运算，你可能会遇到问题，因为信件放在错误的信箱中。如果有人搬到另一个州——没有转发地址——那么你就有了一个悬空指针。开另一方面——如果邮局转发邮件，那么你就有一个指向指针的指针。）

解决方案25
 1  

通过迭代器来掌握它，这是一个不错的方法……但是继续观察你会看到 Alexandrescu 开始抱怨它们。

许多前 C++ 开发人员（在转储语言之前从未理解迭代器是现代指针）跳转到 C# 并且仍然相信他们有不错的迭代器。

嗯，问题是所有迭代器都与运行时平台（Java/CLR）试图实现的目标完全不同：新的、简单的、每个人都是开发者的用法。 这可能是好的，但他们在紫书中说过一次，甚至在 C 之前和之前都说过：

间接。

一个非常强大的概念，但如果你一直这样做，就永远不会这样了。 迭代器很有用，因为它们有助于算法的抽象，另一个例子。 编译时是算法的地方，非常简单。 您知道代码 + 数据，或使用其他语言 C#：

IEnumerable + LINQ + Massive Framework = 300MB 运行时惩罚间接的糟糕的，通过引用类型实例的堆拖动应用程序..

“Le Pointer 很便宜。”

解决方案26
 0  

每个 C/C++ 初学者都有同样的问题，这个问题的出现不是因为“指针难以学习”，而是“谁以及如何解释它”。 一些学习者口头收集它一些视觉，解释它的最好方法是使用“训练”示例（适用于口头和视觉示例）。

其中“机车”是一个不能容纳任何东西的指针，而“货车”是“机车”试图拉动（或指向）的东西。 之后，您可以对“马车”本身进行分类，它可以容纳动物、植物或人（或它们的组合）。

解决方案27
 0  

只是为了使事情更加混乱，有时您必须使用句柄而不是指针。 句柄是指向指针的指针，因此后端可以移动内存中的内容以对堆进行碎片整理。 如果指针在例行程序中发生变化，结果是不可预测的，因此您首先必须锁定句柄以确保没有任何事情发生。

http://arjay.bc.ca/Modula-2/Text/Ch15/Ch15.8.html#15.8.5比我更连贯地谈论它。 :-)

解决方案28
 0  

我不明白指针有什么令人困惑的地方。 它们指向内存中的一个位置，即它存储的内存地址。 在 C/C++ 中，您可以指定指针指向的类型。 例如：

int* my_int_pointer;

说 my_int_pointer 包含指向包含 int 的位置的地址。

指针的问题在于它们指向内存中的某个位置，因此很容易进入您不应该进入的某个位置。超过分配的边界）。

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 memory barriers 处理的问题到底是什么？ C ++中的内存屏障有哪些例子？ 我是否正确理解了所有这些指针指向的内容？ 使用指针或不使用指针作为类引用。 有什么不同？ C++，泄漏与否？ 可以做什么 了解双指针问题并将其传递给函数 constexpr 指针可以指向哪些类型的对象？ CPU％是关于“可以做什么”而不是“正在发生的事情”是正常的吗？ 指针操作的类型 什么是资源或指针的所有权？
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM