数学就像举重，你举一次就完了，直到下次举重。编程更像有氧运动，你需要不断理解自己在做什么。 有些人就是不擅长脑力有氧运动，但擅长短时间的高强度表现。 数学和编程在认知功能上也不相似，很多数学人擅长计算机科学，很多计算机科学人擅长数学。我属于后者。在数学中，信息处理是纯粹的概念化和无形的信息操作。在计算机科学中，信息与抽象的物理世界相关联。我一直认为计算机科学中这种微小的实体性让事情变得更加直观。有些人对物理世界感到困扰和束缚，更喜欢纯粹的无形和抽象。 回复
我从事计算机科学工作已有20年。我喜欢基础数学——逻辑、代数等。我也喜欢软件工程和编写代码。 但我对理论数学一窍不通。我在所有必修的微积分和微分方程课程中都得了C，当我完成所有这些课程时，我举办了一场派对。 回复
理论数学之所以如此困难，是因为没有编译器，没有代码检查工具，几乎没有关键字。你必须将普通的松散语言转化为严格的定义。而你唯一能检查自己工作的方法就是阅读它并试图打破你的推理。 我在理论数学方面表现不错，但我不打算继续攻读博士学位。 回复
对内存工作原理的基本理解确实重要，再加上需要以地址为单位进行抽象思考并将其转化为语法，这对C++新手来说有点困惑，这需要考虑很多抽象概念，而有些人就是不擅长这方面。 就像大多数非程序员不理解Excel表格中的公式，需要有意识地强迫自己每次重新学习，但第二天又会忘记。这就是为什么我提到有氧运动与力量训练的区别，通过数学考试通常是一次性完成，之后就不再关注，而C++编程则需要完美掌握其运作原理，这并非人人都能做到。 回复
很多擅长数学的人不擅长计算机科学，很多计算机科学的人不擅长数学 从未在任何地方见过这种说法；而这显然有其原因： 两者都是智商的直接函数！ 如果你擅长其中一项，另一项也会变得容易。如果你不擅长其中一项，那么另一项你肯定也不擅长。 人们可能会有不同的看法，因为他们本身就不擅长这两项，因此无法做出判断。（尤其是那些从事计算机相关工作的人，他们常常高估自己的认知能力……数学才是衡量智商的更好指标。） 当然，从未接触过某件事的人不可能擅长它。因此，即使是一个数学天才，如果从未学习过计算机科学，也不会（立即）擅长它（反之亦然；只是这种情况非常罕见，因为数学在小学阶段就已经开始学习了）。一个智商高的人可以很快掌握另一件事，并很快在其中脱颖而出。这就是重点。 智商并不会让你自动在某件事上更出色。它主要让你能够更快地掌握新事物。当然，你的上限也会更高，因为你可以掌握更复杂的内容。 除此之外，最初的论点完全没有意义，因为事实上（高级）计算机科学就是数学。理论计算机科学是数学的一个分支，与其中最复杂和抽象的部分紧密相连。机器所做的一切，其核心都基于数学理论。 对于普通程序员来说：只需看看“日常工作”如代码解释背后的理论，你很快就会发现自己陷入了非常复杂的数学话题。 回复
我坦白说，可能是*和&让它们感到困惑，区分两者确实有难度。以我个人经验，汇编语言在这两者中处理得更好，尤其是在MOV和LEA指令的区别上。在NASM中，使用括号从内存地址读取数据时，没有括号的变量直接表示地址，这更容易理解。 在C或C++中，我真的很难分辨是读取地址还是值。我认为这可能是因为C省略了那些让它直观的步骤，但当时C发布时，对于来自汇编语言的程序员来说，这完全有道理。 回复
对我来说，这是C语言最常见的写法： int *ptr; *ptr = 20; 这让我感到非常困惑，因为第一行看起来像是声明了一个整型变量。有一种等效且更好的（我认为）风格，同样符合C语言规范： int* ptr; *ptr = 20; 这清楚地表明 ptr 是一个 int 指针。但这种语法仍然令人困惑，因为 int* ptr; 并不直观——对我来说，它应该是 int& ptr;。这样更合理，因为我们会使用 & 声明或创建地址/引用，并使用 * 访问引用的值。事实上，其他语言也使用这种语法，例如 Rust： // Rust let number: i32 = 42; let number_ref: &i32 = &number; println!(“通过引用的值是：{}”, *number_ref); 回复
对于C/C++知识有限的人来说，痛苦更多来自于一切都变成指针，而软件规模越大，出现内存漏洞的概率就越高。随着经验的积累，就像所有语言一样会变得容易，但它们似乎总是痛点。 请不要太当真，我从未真正学习过C/C++，我只用OpenGL创建过训练程序并绘制过一些几何图形。不过我确实喜欢用C语言编写和学习汇编代码，哈哈 回复
那么我不明白你所说的C/C++将一切转换为指针是什么意思。C/C++只是文本。它什么都不做，哈哈 编辑：“代码的具体形式对开发者来说并不重要”：https://en.wikipedia.org/wiki/Leaky_abstraction 如果你连计算机架构的基本知识都不了解，你期待如何正确编程？ 回复
根据我的经验，主要问题是从 GC 切换到 C++ 时没有足够时间好好学习它。他们往往会在每个函数参数中意外复制昂贵的对象（如向量），但如果你所在的团队成员都懂 C++，他们会默认使用 const T&，这并不是什么大问题 回复
我一开始很难理解它们，但当时我才18岁，自学一本书，这是我学过的第一门编程语言。但问题不在于我认为它们很难，而是我长期以来没有真正理解它们，经常误用，直到我学得更好。我认为它们很简单，只是我实际上不明白它们是如何工作的。当我最终真正学会后，我仍然觉得它们很简单。我认为我使用的书可能有一些缺陷。 回复
我记得刚开始学习C++时，每次写代码都会这样： int pointer = *a 不，这样不对 int pointer = &a 嗯，是这样吗？ int& pointer = *a 嗯，不对不对不对 int* pointer = &a 啊，就是这样 但情况也就糟糕到这种程度了 回复
是的，我的语法是正确的，没有搞混。我只是不太理解内存管理。我猜用*既表示指针类型又表示解引用运算符确实有点让人困惑，但如果你学会将例如int *视为“指向int的指针”作为一个整体，而不被*出现在变量名上的事实分散注意力，那就容易理解了。 回复
学习C++时我对指针和引用一无所知。事实上，我甚至对C++的具体概念都很模糊，只知道可以用它编程。在那之前，我唯一用过的编程语言是TI84+的BASIC和z80汇编，而我学习C++的唯一资料（当时我以为C++和C是一样的）是一本在父亲房间里找到的书。我也没有C++编译器，所以无法实际尝试任何代码。 回复
我记得当时不得不使用一些非常复杂的语法，因为我的教授非常喜欢递归函数。 比如： ptr.class-data1->recursive_call_left(); ptr.class-data2->recursive_call_right(); 用于填充二叉树的数据。虽然我记得每行有2或3个“->”，但我得翻出旧的U盘才能确认 回复
-> 操作符与点运算符的概念完全相同，只是它会为你解引用指针值。与递归无关。如果没有 ->，你每次都需要做类似 (*variable).func() 的操作，而不是直接使用 variable->func()。 虽然语法稍显混乱，但做过数百次后就没什么大不了的了。 回复
我知道这与递归没有直接关系。只是为了作业，如果我记得没错的话，我们需要使用尽可能少的行数。因此，递归函数一次处理了类结构中的大量数据，这意味着一行中需要引用大量内容。我认为树甚至是以链表结构组织的。 但没错，这是我第一次接触指针和递归，当时觉得这一切都像某种巫术。 回复
如果没有先被教导内存只是一个巨大的字节数组，这些概念真的很难理解。 C和C++中指针的“只是内存地址”模型简单、直观，但错误。 编辑：我猜我被点赞是因为人们认为我的第二个观点是错误的，但去读标准或我写在这方面的文档。C和C++中的指针比大多数C和C++程序员认为的要奇怪得多。 回复
不，虽然这更接近了。 C++编译器处理内存的方式比简单的“内存是一个大数组”系统严格得多。基本上：在C++虚拟机（定义C++行为的假想机器）中，每个指针都有一个“区域”，通常是一个内存分配、一个栈变量或一个静态变量，你不能对指向不同区域的变量做很多事情。例如，以下代码在 C 和 C++ 中（直到 C++23）属于未定义行为： bool f() { int s, t; return &s > &t; // 未定义 } 你也不允许对指针进行序列化和反序列化（至少在 C++23 之前，标准中的语言发生了变化，我无法确定具体情况）： int f() { int z = 1; std::stringstream s; void *zptr; s << &z; s >> zptr; // 未定义（直到 C++23？） return *reinterpret_cast<int*>(zptr); } … 不过 printf() 函数的 %p 指定符是特殊处理的，因此这始终是允许的： int f() { int z = 1; char buf[200]; void *zptr; snprintf(buf, sizeof buf, “%p”, &z); sscanf(buf, “%p”, &zptr); // 正常 return *reinterpret_cast<int*>(zptr); } 我之前写过一篇关于这些内容的较长文档，但简而言之： 99%的C和C++开发者对C和C++中的指针和内存模型存在误解，如果在使用指针时稍有偏差，可能会引发各种问题。 回复
你可以遵循以下规则： – 始终假设指针可能为空指针。 – 若需非空指针，使用引用。 – 若需将引用存储在容器中，使用std::reference_wrapper。 然后，解引用只是在你想使用“可空引用”时的问题，只需在解引用前检查是否为空指针。顺便说一下，指针和引用应该是无所有权的。如果你想要一个可空的所有权值，使用std::optional。 回复
使用指针作为参数或返回值是完全有效的。它们表明该值是“借用”的，可能为空，且函数无需关心所指值的生命周期。 如果指针是拥有型指针，那么你的说法是正确的。根据需求，使用std::optional通常已足够，无需考虑智能指针。 回复
在类内部，你可以使用原始指针作为优化手段以避免开销，这当然可行。在两个仅通过接口相互交互的类之间，除了 C 级别的 I/O 之外，传递原始指针对我来说是一种代码臭味——我从 C++98 之前就开始使用 C++，所以并不是我不熟悉如何在没有 std 保护机制的情况下暗示/推断所有权，我只是看到为什么应该尽可能避免这样做。 回复
当然，我理解你的观点，并且在大部分情况下我同意你。但有时你需要支持空值。使用std::optional<std::reference_wrapper<T>>并不方便。这真是遗憾，因为你无法将引用存储在std::optional中。这也会让模板元编程变得更复杂，因为你需要通过将其包装到std::reference_wrapper中来处理这种特殊情况。 回复
不，兄弟。对于一个不拥有权的参数，你传递一个（可能是const的）引用。对于一个应该被拥有的参数，你传递一个std::unique_ptr来表示所有权的转移。 如果你要返回一个对返回方来说是未拥有的值，就返回一个引用。如果你要返回一个需要返回方接管所有权的值，可以直接返回值并让 RAII 处理，或者返回一个 std::unique_ptr 来表示所有权转移。 回复
没错。但有时需要空指针兼容性，引用无法提供这一点。理想情况下应使用 std::optional 与引用配合，但遗憾的是它无法存储引用。编写 std::optional<std::reference_wrapper<T>> 过于繁琐，获取值也更麻烦且增加不必要的噪音。这种情况下我倾向于使用指针。另一种方案不够优雅。 U* foo(T* t); vs std::optional<std::reference_wrapper<U>> foo(std::optional<std::reference_wrapper<T>> t); 回复
说实话，我认为至少有一半的问题在于，指针语法在没有熟练掌握之前很难理解。当我第一次接触指针时，感觉那些*和&符号有一半时间都搞反了。我仍然认为指针声明用string& foo会更直观，但实际上这些符号用于引用，虽然概念上与指针相似，但语法上有所不同。 再加上当你玩弄示例时，可能会遇到一些看起来像正则表达式的行，我能理解为什么会产生很多困惑，即使从概念上讲它们应该相当简单。 回复
如果你在学习C++，是的。但如果你在学习C（我认为这是个自然的起点），关于这门语言本身其实没有太多需要学习的内容，指针完全可以在学习过程中逐步掌握。 事实上，GLSL基本上是C的简化版，但底层语言不支持指针，而且在没有指针的情况下也能完成很多事情。不过它确实有一些类似引用（reference）的概念。 回复
我的意思是，我显然在解决指针相关问题并转向结构和算法之前，已经学习了指针的语法和工作原理。但那是在我完成上述所有内容之后。 我需要指出的是，我在第三和第四学期用C++学习了数据结构与算法（DSA），当时我们分别学习了结构体（第三学期）和算法（第四学期）。 我们在第一学期就学习了C语言的全部语法，你可能说得对，指针和引用在那时就出现了。但我真的不记得那些课上的任何内容。 回复
我正在帮助一位朋友重返大学学习编程课程，指针是基础课程1中的倒数第二个主题，所以肯定是在非常早的阶段就学到的。 编辑：应该说明他们是从C++开始学习的 另外，我刚注意到你的标签，你是什么意思，你只写汇编语言…… 回复
指针很简单。它就像一个书签。你使用&在变量开头创建一个书签，使用*返回书签中的内容。你可以将书签放在任何地方，甚至未分配的内存中，但指向数组中的元素或变量/对象开头的书签最为常见。你使用类型转换来设置类型，当编译器无法确定类型时。 回复
这里有一个解释：https://www.reddit.com/r/ProgrammerHumor/comments/wq5nlx/my_new_favorite_way_to_explain_pointers_to_newbies/ 回复
我作为一名资深汇编语言程序员进入C语言领域。不知为何，指针和解引用相关的内容让我感到困惑。那些变量前或类型声明后的星号，还有&符号……这是什么情况？后来我意识到，由于在接触高级语言抽象形式之前，我的大脑已经内化了机器语言的机制，因此产生了一种“倒置摩擦”般的认知冲突。我的其他同事也遇到了同样的问题。当我放弃那种自底向上的视角后，C语言的内容逐渐变得自然。有趣的是，后来我又将自底向上的部分重新引入到我的思维中，那种摩擦感却没有再出现。我从未见过那些先学习C语言再学习汇编语言的程序员出现这种情况。非常奇怪。 编辑：修正了变量前后标记的问题 回复
接下来你要说的是互斥锁很难理解。 这就是那种到处都是共享指针的代码。 没关系，孩子，让它超出作用域吧。让岩石管理你的内存，然后在它挂起时抱怨，随意。 不要删除你不懂的那个函数，因为它使用了模板。 将所有变量都声明为静态内联。这并非全局变量，因为它仍在类内部。 回复
唉……什么？我在六年级小学就学过指针和引用，当时是个简单的概念，后来更简单了。我认为从编程基础来看，只有安全的并发模式有点复杂。在C++中，高级模板可能更复杂，但即使如此，主要是因为语法（这在概念等中大多已解决）。 否则，我认为只有干净的软件架构、算法、相关数学和物理才是真正复杂的。 回复
做作业
为了你的国家
我在信息系统学士学位的第三学期学到了这个，兄弟。去做好作业吧 😭😭😭
对啊兄弟，这种事初中生才会做
兄弟我从来没做过
我十年前在大学里学过Java和C#。我是学商业信息系统的，不是计算机科学。我现在才开始学指针，因为我要扩展到Go语言。
Java里也有指针，这就是为什么你不能用==来比较字符串
Java在非基本类型变量之间支持引用相等性，但不支持指针。指针是一种Java不支持的变量类型。即使JavaScript也支持引用相等性
引用本质上就是指针，只是Java不允许进行指针运算。
你正在使用指针的两种不同含义。你可以说引用是指针，因为它们指向一个地址，但你不能说Java支持指针，因为指针是语言的一项特性。
我们在大二学期学过这个，哈哈
我正在第一学期学习这个，哈哈，接下来他可能会抱怨运算符重载
内存地址和包含它们的变量有什么难懂的
这可能是本科生发的一个他们认为相关的笑话
我一直不明白，到了这个阶段，你应该已经上过数学课了。你怎么能通过实分析或代数，却无法理解这个？
数学就像举重，你举一次就完了，直到下次举重。编程更像有氧运动，你需要不断理解自己在做什么。
有些人就是不擅长脑力有氧运动，但擅长短时间的高强度表现。
数学和编程在认知功能上也不相似，很多数学人擅长计算机科学，很多计算机科学人擅长数学。我属于后者。在数学中，信息处理是纯粹的概念化和无形的信息操作。在计算机科学中，信息与抽象的物理世界相关联。我一直认为计算机科学中这种微小的实体性让事情变得更加直观。有些人对物理世界感到困扰和束缚，更喜欢纯粹的无形和抽象。
我从事计算机科学工作已有20年。我喜欢基础数学——逻辑、代数等。我也喜欢软件工程和编写代码。
但我对理论数学一窍不通。我在所有必修的微积分和微分方程课程中都得了C，当我完成所有这些课程时，我举办了一场派对。
理论数学之所以如此困难，是因为没有编译器，没有代码检查工具，几乎没有关键字。你必须将普通的松散语言转化为严格的定义。而你唯一能检查自己工作的方法就是阅读它并试图打破你的推理。
我在理论数学方面表现不错，但我不打算继续攻读博士学位。
本科数学：1 + 1 = 2
博士数学：证明1 + 1 = 2
哈哈，算了吧，我还是用我的二次公式吧
我对数学课的感受完全相同。令人惊讶的是，我非常喜欢物理课，感觉就像在解谜题，而且逻辑性更强。而且还有公式表。
我不是在谈论编程。对内存工作原理的基本理解并非“脑力锻炼”，与认知或抽象思维方式无关。大多数非程序员甚至能理解Excel表格的工作原理。
对内存工作原理的基本理解确实重要，再加上需要以地址为单位进行抽象思考并将其转化为语法，这对C++新手来说有点困惑，这需要考虑很多抽象概念，而有些人就是不擅长这方面。
就像大多数非程序员不理解Excel表格中的公式，需要有意识地强迫自己每次重新学习，但第二天又会忘记。这就是为什么我提到有氧运动与力量训练的区别，通过数学考试通常是一次性完成，之后就不再关注，而C++编程则需要完美掌握其运作原理，这并非人人都能做到。
我因为数学而辍学，但我在编程方面表现出色（至少是基础的，一年级和二年级的编程）。我仍然不明白为什么我会这样，但你的帖子有道理。
从未在任何地方见过这种说法；而这显然有其原因：
两者都是智商的直接函数！
如果你擅长其中一项，另一项也会变得容易。如果你不擅长其中一项，那么另一项你肯定也不擅长。
人们可能会有不同的看法，因为他们本身就不擅长这两项，因此无法做出判断。（尤其是那些从事计算机相关工作的人，他们常常高估自己的认知能力……数学才是衡量智商的更好指标。）
当然，从未接触过某件事的人不可能擅长它。因此，即使是一个数学天才，如果从未学习过计算机科学，也不会（立即）擅长它（反之亦然；只是这种情况非常罕见，因为数学在小学阶段就已经开始学习了）。一个智商高的人可以很快掌握另一件事，并很快在其中脱颖而出。这就是重点。
智商并不会让你自动在某件事上更出色。它主要让你能够更快地掌握新事物。当然，你的上限也会更高，因为你可以掌握更复杂的内容。
除此之外，最初的论点完全没有意义，因为事实上（高级）计算机科学就是数学。理论计算机科学是数学的一个分支，与其中最复杂和抽象的部分紧密相连。机器所做的一切，其核心都基于数学理论。
对于普通程序员来说：只需看看“日常工作”如代码解释背后的理论，你很快就会发现自己陷入了非常复杂的数学话题。
我认识一些不怎么编程的数学家，但如果他们愿意涉足计算机科学这一数学分支，我敢肯定他们都会比我更擅长计算机科学。你不可能在数学上很擅长却在计算机科学上很糟糕，因为计算机科学就是数学。
你认为计算机科学专业的学生会学习实分析或抽象代数吗？通常他们的数学要求止于线性代数，而且往往是计算量很大的线性代数。
不确定其他地方的情况，但在德国我确实需要学习。但我觉得我所在的大学数学要求比较高，所以不确定，我以为这是正常的
不，通常美国顶尖大学对数学的要求最高是离散数学、多元微积分和向量微积分、微分方程以及线性代数。
我的学校不允许计算机科学专业学生辅修数学<我从未实际核实过，但听说我们可能无需额外课程就能符合条件>。不，但我记得在面试实习时，他们曾评论说我的学校数学要求很高。
这跟代数有什么关系？
你在哪个学校学过需要用到实分析的计算机科学课程？
本科生在发现内存寻址是每种编程语言底层机制时。
这样的梗让我对未来的工作充满信心。如果指针对你来说太难，那在哪个宇宙里你能做出有趣的东西？
我坦白说，可能是*和&让它们感到困惑，区分两者确实有难度。以我个人经验，汇编语言在这两者中处理得更好，尤其是在MOV和LEA指令的区别上。在NASM中，使用括号从内存地址读取数据时，没有括号的变量直接表示地址，这更容易理解。
在C或C++中，我真的很难分辨是读取地址还是值。我认为这可能是因为C省略了那些让它直观的步骤，但当时C发布时，对于来自汇编语言的程序员来说，这完全有道理。
C和C++的最大问题在于，你可以编写出非常难以阅读的代码。我很快意识到这一点，因为我经常会对几个月前自己写的糟糕代码感到困惑。使用C++，你可以编写优雅且快速的代码，几乎不需要使用*和&。
我能给新程序员的最佳建议是，真正理解运算符、表达式和语句的含义。我见过一些编程十年的人仍在为此苦恼。
我认为它们并非难以理解，而是因为它们是人们首先接触到的工具，如果不谨慎使用，这些工具锋利到足以让你自断喉咙。你必须真正明白自己在做什么。
跟踪间接层级。
我学习指针时花了一段时间才掌握。我理解基本原理，但真正直观地理解它们却花了一段时间。
指针运算就像化学中的平衡方程式——第一次看到时觉得是黑魔法，但熟悉后就变得有趣了。
对我来说，这是C语言最常见的写法：
int *ptr; *ptr = 20;
这让我感到非常困惑，因为第一行看起来像是声明了一个整型变量。有一种等效且更好的（我认为）风格，同样符合C语言规范：
int* ptr; *ptr = 20;
这清楚地表明 ptr 是一个 int 指针。但这种语法仍然令人困惑，因为 int* ptr; 并不直观——对我来说，它应该是 int& ptr;。这样更合理，因为我们会使用 & 声明或创建地址/引用，并使用 * 访问引用的值。事实上，其他语言也使用这种语法，例如 Rust：
// Rust let number: i32 = 42; let number_ref: &i32 = &number; println!(“通过引用的值是：{}”, *number_ref);
我的 C 语言有点生疏了（呵呵），但我认为你的 C 代码会发生段错误。
是的，当前指针指向任意位置
你需要为其分配内存
我总是使用 int *ptr，因为 * 修改的是变量，而非类型。int &ptr 是 C++ 中声明引用的一种方式，不过我认为它需要初始化，因此应为 int &ref = val;
说实话，95%的C++代码都可以且应该使用std::unique_ptr（剩下的应该使用std::shared_ptr），因此几乎不需要关心指针。
智能指针绝不是指针的替代品。它们用于管理动态分配对象的生命周期，而对于静态分配的对象，几乎没有可行的使用场景。这是另一个被严重误解的概念。
对于C/C++知识有限的人来说，痛苦更多来自于一切都变成指针，而软件规模越大，出现内存漏洞的概率就越高。随着经验的积累，就像所有语言一样会变得容易，但它们似乎总是痛点。
请不要太当真，我从未真正学习过C/C++，我只用OpenGL创建过训练程序并绘制过一些几何图形。不过我确实喜欢用C语言编写和学习汇编代码，哈哈
嗯。C/C++并不是把一切都转换成指针。在每种编程语言中，一切都是指针。C/C++只是让你以指针的形式访问它，而其他语言则试图隐藏这一点。
不，代码只是文本，直到它经过编译器并成为机器码。它看起来像什么与开发者无关。其他语言通常也提供指针，所以我不知道你评论的意义所在，哈哈
那么我不明白你所说的C/C++将一切转换为指针是什么意思。C/C++只是文本。它什么都不做，哈哈
编辑：“代码的具体形式对开发者来说并不重要”：https://en.wikipedia.org/wiki/Leaky_abstraction
如果你连计算机架构的基本知识都不了解，你期待如何正确编程？
我说代码中有指针，这会导致内存错误。对于泄露的抽象，如果你真的期望开发者在编译后使用反编译器查看机器码，我不知道该怎么说。
即使在我上学的时候，我也搞不懂为什么指针对别人来说这么难理解。解释内存的工作原理，并展示一个链表的例子，这应该足以理解这个概念。
我认为这个梗是讽刺的
讽刺在哪里？
它从这里开始：如果你不知道如何处理指针和引用，那你肯定不是C++开发者。到目前为止，你顶多是在尝试学习C++。
这个梗简直蠢透了。可能是诱饵，不过……（而且这次确实很成功！😂）
确实可能是诱饵，仅凭文字很难分辨。
通常是关于如何分配内存以及分配多少。所以是动态内存
我不使用C++，所以每次想“哦，我再试一次”时，我总是忘记哪个字符做什么。
我从未觉得这很难。还是为那张搞笑的腹肌照片被PS到额头上的图片点赞了。
指针很容易理解。但我有时还是会被引用搞糊涂。有两种东西做的事情差不多，但又不完全一样，这让人困惑。
我停止称它为“引用”，开始称它为“地址”后，情况有所改善。你获取一个值的地址来创建一个原始指针。希望这对你有帮助。
你混淆了&运算符的两种不同用法。引用不是地址，它们被操作的方式与对象本身相同，而不是作为其地址。对变量使用&运算符会给你它的地址，一个指针，但那不是引用。
感谢你的澄清。
不。指针和引用很简单。
是的，我一直不明白这一点。当我学习C++时，我对指针感到焦虑，因为我听说了太多关于它们的事情，但实际上它们只是一个内存地址，而不是某个值。我不知道，但这对我来说有道理，哈哈。
是的，我认为从概念上讲它们并不难。安全地管理它们才是挑战，但这是另一个问题，通常可以通过使用RAII、内存池或其他内存管理模式来解决，具体取决于情况
而且大多数时候你甚至不需要管理任何东西，标准库中的所有对象都实现了RAII，并完全隐藏了内存的分配和释放过程
哦，当然。我的意思是，我在带GC的语言中看到的垃圾代码简直令人发指，我只能想象在大型C++代码库中会有多糟糕，哈哈
根据我的经验，主要问题是从 GC 切换到 C++ 时没有足够时间好好学习它。他们往往会在每个函数参数中意外复制昂贵的对象（如向量），但如果你所在的团队成员都懂 C++，他们会默认使用 const T&，这并不是什么大问题
我一开始很难理解它们，但当时我才18岁，自学一本书，这是我学过的第一门编程语言。但问题不在于我认为它们很难，而是我长期以来没有真正理解它们，经常误用，直到我学得更好。我认为它们很简单，只是我实际上不明白它们是如何工作的。当我最终真正学会后，我仍然觉得它们很简单。我认为我使用的书可能有一些缺陷。
我记得刚开始学习C++时，每次写代码都会这样：
不，这样不对
嗯，是这样吗？
嗯，不对不对不对
啊，就是这样
但情况也就糟糕到这种程度了
是的，我的语法是正确的，没有搞混。我只是不太理解内存管理。我猜用*既表示指针类型又表示解引用运算符确实有点让人困惑，但如果你学会将例如int *视为“指向int的指针”作为一个整体，而不被*出现在变量名上的事实分散注意力，那就容易理解了。
我经常写C++和C，但仍然需要反复检查。不知为何，这些概念始终无法在我脑海中根深蒂固。
对吧？我很难理解没有指针的情况下人们如何完成任何操作。这是我学习其他内容时最大的障碍。而且我其实也没真正掌握指针和引用。如果需要解引用，我宁愿先去做点别的
学习C++时我对指针和引用一无所知。事实上，我甚至对C++的具体概念都很模糊，只知道可以用它编程。在那之前，我唯一用过的编程语言是TI84+的BASIC和z80汇编，而我学习C++的唯一资料（当时我以为C++和C是一样的）是一本在父亲房间里找到的书。我也没有C++编译器，所以无法实际尝试任何代码。
我记得当时不得不使用一些非常复杂的语法，因为我的教授非常喜欢递归函数。
比如：
ptr.class-data1->recursive_call_left();
ptr.class-data2->recursive_call_right();
用于填充二叉树的数据。虽然我记得每行有2或3个“->”，但我得翻出旧的U盘才能确认
-> 操作符与点运算符的概念完全相同，只是它会为你解引用指针值。与递归无关。如果没有 ->，你每次都需要做类似 (*variable).func() 的操作，而不是直接使用 variable->func()。
虽然语法稍显混乱，但做过数百次后就没什么大不了的了。
我知道这与递归没有直接关系。只是为了作业，如果我记得没错的话，我们需要使用尽可能少的行数。因此，递归函数一次处理了类结构中的大量数据，这意味着一行中需要引用大量内容。我认为树甚至是以链表结构组织的。
但没错，这是我第一次接触指针和递归，当时觉得这一切都像某种巫术。
同感！我开始觉得，如果人们不明白变量是如何存储的，他们就会在理解上遇到困难。说真的，内存就是一个巨大的数组，变量就是对该数组中某一部分的符号引用，指针就是该数组中变量的位置索引。
如果没有先被教导内存只是一个巨大的字节数组，这些概念真的很难理解。
C和C++中指针的“只是内存地址”模型简单、直观，但错误。
编辑：我猜我被点赞是因为人们认为我的第二个观点是错误的，但去读标准或我写在这方面的文档。C和C++中的指针比大多数C和C++程序员认为的要奇怪得多。
为什么错误？
好的
这是有类型的内存地址，这样在处理数组时指针运算才有用。满意了吗？
不，虽然这更接近了。
C++编译器处理内存的方式比简单的“内存是一个大数组”系统严格得多。基本上：在C++虚拟机（定义C++行为的假想机器）中，每个指针都有一个“区域”，通常是一个内存分配、一个栈变量或一个静态变量，你不能对指向不同区域的变量做很多事情。例如，以下代码在 C 和 C++ 中（直到 C++23）属于未定义行为：
bool f() { int s, t; return &s > &t; // 未定义 }你也不允许对指针进行序列化和反序列化（至少在 C++23 之前，标准中的语言发生了变化，我无法确定具体情况）：
int f() { int z = 1; std::stringstream s; void *zptr; s << &z; s >> zptr; // 未定义（直到 C++23？） return *reinterpret_cast<int*>(zptr); }…
不过 printf() 函数的 %p 指定符是特殊处理的，因此这始终是允许的：
int f() { int z = 1; char buf[200]; void *zptr; snprintf(buf, sizeof buf, “%p”, &z); sscanf(buf, “%p”, &zptr); // 正常 return *reinterpret_cast<int*>(zptr); }我之前写过一篇关于这些内容的较长文档，但简而言之： 99%的C和C++开发者对C和C++中的指针和内存模型存在误解，如果在使用指针时稍有偏差，可能会引发各种问题。
如果标题是“C++开发者在学习指针和引用后会有什么感受”，会更好。
不，那是在学习高级模板元编程之后。
不，这很简单。这是在使用 Boost 预处理器库五分钟之后（我大概十年没做过模板元编程了，希望这仍然相关。）
不，这很简单。这是在重新编程现实，覆盖几乎所有边界情况，结果却在撞到桌子边缘时出错。
不，这很简单。这是在弄清楚如何退出Vim。
是的，他们正在添加参数包索引，并做了一大堆上下文相关的东西
是的，但你得扩展它。编写代码需要花费大量时间和精力，这在很多地方都变得低效，而这些地方我们无法外包。
对于vibecoders来说，这很难
对他们来说一切都很困难，这就是为什么他们是 vibe 编码者。
不要嘲笑有特殊需求的人！
vibe 编码者天生就是这样。
并非每个人都幸运地拥有一个完全正常运作的大脑。
了解指针和引用：简单
判断在C++代码库中解引用指针/引用是否安全：困难
如果你在做一些让解引用引用变得不安全的事情，那你真的在编码时搞砸了。
这个
说实话，我还是不太清楚。你能给我一些建议吗？哈哈
尽可能使用引用。在无法使用引用的情况下使用智能指针。仅在确实需要时使用原始指针，且不应将其用于转移内存的“所有权”。
我指的是第二行关于知道在哪里安全地解引用
这就是为什么在可能的情况下使用引用。这意味着存在性检查已经完成。总之，尽量让代码在错误时无法编译。
你可以遵循以下规则： – 始终假设指针可能为空指针。 – 若需非空指针，使用引用。 – 若需将引用存储在容器中，使用std::reference_wrapper。
然后，解引用只是在你想使用“可空引用”时的问题，只需在解引用前检查是否为空指针。顺便说一下，指针和引用应该是无所有权的。如果你想要一个可空的所有权值，使用std::optional。
嗯，你不需要解引用引用，所以这个还算简单，至少目前是这样。
没错，是我疏忽了
为什么你在2025年的C++代码库中仍然使用原始指针作为参数或返回值？自C++11以来，我们就有智能指针了。在现代C++中，只要应用RAII和移动语义，这根本不是问题。
使用指针作为参数或返回值是完全有效的。它们表明该值是“借用”的，可能为空，且函数无需关心所指值的生命周期。
如果指针是拥有型指针，那么你的说法是正确的。根据需求，使用std::optional通常已足够，无需考虑智能指针。
在类内部，你可以使用原始指针作为优化手段以避免开销，这当然可行。在两个仅通过接口相互交互的类之间，除了 C 级别的 I/O 之外，传递原始指针对我来说是一种代码臭味——我从 C++98 之前就开始使用 C++，所以并不是我不熟悉如何在没有 std 保护机制的情况下暗示/推断所有权，我只是看到为什么应该尽可能避免这样做。
当然，我理解你的观点，并且在大部分情况下我同意你。但有时你需要支持空值。使用std::optional<std::reference_wrapper<T>>并不方便。这真是遗憾，因为你无法将引用存储在std::optional中。这也会让模板元编程变得更复杂，因为你需要通过将其包装到std::reference_wrapper中来处理这种特殊情况。
不，兄弟。对于一个不拥有权的参数，你传递一个（可能是const的）引用。对于一个应该被拥有的参数，你传递一个std::unique_ptr来表示所有权的转移。
如果你要返回一个对返回方来说是未拥有的值，就返回一个引用。如果你要返回一个需要返回方接管所有权的值，可以直接返回值并让 RAII 处理，或者返回一个 std::unique_ptr 来表示所有权转移。
没错。但有时需要空指针兼容性，引用无法提供这一点。理想情况下应使用 std::optional 与引用配合，但遗憾的是它无法存储引用。编写 std::optional<std::reference_wrapper<T>> 过于繁琐，获取值也更麻烦且增加不必要的噪音。这种情况下我倾向于使用指针。另一种方案不够优雅。
U* foo(T* t);
vs
std::optional<std::reference_wrapper<U>> foo(std::optional<std::reference_wrapper<T>> t);
因为我的代码库必须在 C++98 标准下编译
如果你无法跟踪你分配的内存及其生命周期，只是在代码中随意使用引用计数，那么你没有资格对其他程序员在“2025 年”的做法指手画脚
我认为指针就是那种你必须反复撞墙才能理解的东西，最终它会豁然开朗，让你纳闷之前为何会为此苦恼
这是我从Java转过来的经历
说实话，我认为至少有一半的问题在于，指针语法在没有熟练掌握之前很难理解。当我第一次接触指针时，感觉那些*和&符号有一半时间都搞反了。我仍然认为指针声明用string& foo会更直观，但实际上这些符号用于引用，虽然概念上与指针相似，但语法上有所不同。
再加上当你玩弄示例时，可能会遇到一些看起来像正则表达式的行，我能理解为什么会产生很多困惑，即使从概念上讲它们应该相当简单。
没错，实现它们的使用方式确实很难。
对我来说，到目前为止最难的是学习移动语义、右值和左值
而std::move实际上并没有移动任何东西，它只是将一个左值转换为右值
直到你遇到一些20年前的代码，这些代码通过引用拦截函数参数并重新赋值
这不是你需要首先学习的内容之一吗？
不一定。对我来说，这是学习过程中的中间阶段
在不知道指针和引用之前，你是如何完成任何工作的？
我的意思是，如果你是从零开始学习编程，那么在学习指针之前，还有很多其他东西需要先掌握。
[已删除]
如果你在学习C++，是的。但如果你在学习C（我认为这是个自然的起点），关于这门语言本身其实没有太多需要学习的内容，指针完全可以在学习过程中逐步掌握。
事实上，GLSL基本上是C的简化版，但底层语言不支持指针，而且在没有指针的情况下也能完成很多事情。不过它确实有一些类似引用（reference）的概念。
C语言中的指针大约在第三周学习。
是的，之后关于语言本身其实没有太多需要学习的内容。可能包括动态内存分配、预处理器、链接和编译，以及文件输入输出。
可能从C++开始学习而不是C，因为C++的STL会尽最大努力让你避免使用它们
正确。
大学第一学期教我C语言，但我一点也没记住。
在学习指针之前，你可以先掌握一些基础知识，比如循环、函数、打印等。
我是以Leetcode为先的方式学习的。我从位操作、数组、二进制搜索、排序、复杂度等相关知识开始。这些问题不需要理解指针和引用。
我在完成所有这些内容后才学习指针。
但你至少需要了解指针的语法并理解它们的含义，对吧？虽然你可能自己没有使用过指针，但我认为你看到的某些代码示例在不了解这些语法的情况下会难以理解。
我的意思是，我显然在解决指针相关问题并转向结构和算法之前，已经学习了指针的语法和工作原理。但那是在我完成上述所有内容之后。
我需要指出的是，我在第三和第四学期用C++学习了数据结构与算法（DSA），当时我们分别学习了结构体（第三学期）和算法（第四学期）。
我们在第一学期就学习了C语言的全部语法，你可能说得对，指针和引用在那时就出现了。但我真的不记得那些课上的任何内容。
实际上，没有它们也能做很多事情
但我指的是能够阅读和理解代码示例。在一个学期中几乎不看到不使用它们的示例是非常罕见的。
不完全是
这取决于你使用的编程语言。高级语言（如C#、Python等）可以根据你的需求隐藏具体实现细节，但C/C++则需要你亲手完成所有操作。
即使在C++中，标准库也能帮你完成大量繁重的工作
我不知道你们的情况，但我的课程不允许使用标准库的大部分功能
我们从未学过这些内容。我们从Java开始学习，前端使用JavaScript，脚本则使用Python或Bash。我至今仍不理解指针
可能是因为你们学的是完全不同的语言？如果你学习C语言，就会立即明白指针的重要性。
我直到开始学习数组时才接触到指针
我正在帮助一位朋友重返大学学习编程课程，指针是基础课程1中的倒数第二个主题，所以肯定是在非常早的阶段就学到的。
编辑：应该说明他们是从C++开始学习的
另外，我刚注意到你的标签，你是什么意思，你只写汇编语言……
我想添加更多标签，但我在用手机，每次尝试添加标签时，它都会自动更改。所以我只保留了我最喜欢的那个。
我觉得当这个概念第一次出现时，它让人感到困惑，但当你经常使用它时，它就变得很有意义了。
我从未被指针搞糊涂过，说实话……用房屋地址的类比真的很有帮助。
许多新手对“传递位置而非实际数据对象本身”的思维模式感到困惑。这是一种人们很少考虑的抽象层。
我同意这并不难，但初次接触时可能会感到困惑
如果你不理解指针和引用，你真的算得上是C++开发者吗？更像是编程新手而非开发者。
再次感谢r/Im14LearningCode
该死，我本以为能看到一些令人尴尬的计算机科学梗图。现在我失望了。
这不就是最基础的内容吗？
最基础的内容是打印语句、循环和条件语句。指针属于中级内容。
不，这些都是绝对基础。如果你不理解其中任何一个，就无法制作任何有用的项目。
仅仅因为有许多基础知识并且它们通常以某种顺序教授，并不意味着它们对语言来说就 menos 基础
我想制作一个能够将摄氏度转换为华氏度并反之的程序。
我可以不使用指针和引用来实现。但我无法在不了解如何打印语句或实现条件语句的情况下完成。
指针和引用并非一门语言的绝对基础。
仅仅因为这些构造更基础，并不意味着指针不是基础。基础意味着你期望每个C++开发者都能掌握它们。如果你不理解指针，你还没有成为C++开发者。
公平地说，理解打印语句远比指针和引用更高级。大多数高级开发者一生中从未做过。
你所说的“中等”是什么意思？你是指编程水平中等吗？比如，你认为雇佣一个不了解指针工作原理的中级软件开发人员是可以接受的？
你在说什么？中等水平是指在大学期间完成结构化数据结构与算法课程的中途阶段。
就业是怎么回事？
他指的是，这在开发中并不是中等水平的概念，仅仅因为它是大学课程的中间部分。
说得对
这意味着你可以成为一名C++开发者而无需了解指针和引用。这就像成为一名Python开发者却不知道如何导入模块一样
让我惊讶的是这些评论。你怎么可能在不知道指针的情况下编写C++代码？
当今计算机科学学生的现状
请别把我在实际开发子版块的兴趣与初中宅男梗混为一谈
这是初级开发内容。这是通过引用向函数传递参数的方式。
那家伙的额头比我的肚子还有六块腹肌。
这很简单。我认为Java很难，因为它的语法太复杂，而且一切都带有面向对象编程的元素，你必须完美掌握这些元素，否则其他概念会显得混乱
为什么人们认为指针难以理解？
哦，是的，太难了！一个带有内存地址的变量！
如果你不掌握指针，你怎么用C++编程？😂
8109个赞… 这个子版块是个笑话。
Python程序员在从行缩进过渡到大括号时。
指针很简单。它就像一个书签。你使用&在变量开头创建一个书签，使用*返回书签中的内容。你可以将书签放在任何地方，甚至未分配的内存中，但指向数组中的元素或变量/对象开头的书签最为常见。你使用类型转换来设置类型，当编译器无法确定类型时。
Qapla’!
今天是个好日子去死。
你变成克林贡人了？
我从未对指针理论有过问题，但使用它们时总是困扰，因为我总是记不住该用哪个符号（*、&、-> 等），所以我倾向于避免使用那些为我管理内存的语言
有趣的是，这个梗提到了C语言中的指针。如果换成位移操作之类的内容，我倒有点认同
等你意识到所有编程语言都使用内存来存储对象时，你就明白了。
计算机科学应该从汇编语言开始学习。之后学习任何高级语言都会像玩游戏一样轻松。
一开始确实不容易掌握，但这是基础之一……用委婉的说法，你将基于对这些基础的理解学习更复杂的概念。用直白的说法，你将面临更多复杂且困难的挑战。
告诉我你不懂指针，但不要直接说你不懂指针，这篇帖子
我从未理解过那些说这很难的人，即使在我学习的时候也是如此
这可能是内存管理和系统编程中最简单的一部分
如果这很难，那我只能说抱歉，因为你会被淘汰
作为新手可能会觉得奇怪。我刚开始学的时候，觉得把*和名称关联而不是类型很奇怪。说实话，我仍然觉得这没道理，把t: Pointer<T>比作T *t要简单得多
这里有一个解释：https://www.reddit.com/r/ProgrammerHumor/comments/wq5nlx/my_new_favorite_way_to_explain_pointers_to_newbies/
这基本上是学习C++时最早接触的内容之一。尽管我只用C++进行CP开发
那你不是从一开始就是C++开发者吗？
我用C语言时头发更稀疏了
一定是写这个源代码的人的额头，我正在努力修复它。每个函数都是通过指针调用的。
等你了解标准库就知道了
真是太好笑了，这个子版块里大部分都是绝对的新手在发帖 🤣
额头上那是一块六块腹肌吗？
更准确的标题应该是“C/C++开发者在大型代码库中调试内存泄漏”
这太痛苦了。
老实说，我知道很多人对此感到困惑。但我从书本上学到的，而开发者们认为这完全依赖于实践经验。但直到我读了那本书，我才真正理解了这一切。
我刚开始学指针时遇到了困难，一位同事建议我参加现代二进制利用课程（MBE，可在GitHub上找到），在研究汇编代码的过程中，我最终对指针的实际工作原理有了深刻理解。
这里都是初级程序员吗？指针为什么这么难？
哈哈哈……不是
他们变成了克林贡人？
有时候我好奇自己作为生物专业毕业生如何能进入FAANG工作，但看到这样的帖子就明白了。
其实挺简单的。我是说，作为一个还没开始大一课程的18岁学生。
C++开发者在用模板元编程写斐波那契数生成器后。
[steffensregal41@gmail.com](mailto:steffensregal41@gmail.com)
指针本身不难，难的是判断何时该使用指针，何时只需克隆结构体。
更像是学习了移动语义、所有权、复制初始化、直接初始化、列表初始化、返回值省略、智能指针等概念后的 C++ 开发者。
以及 CMake 和预编译头文件
你在说暑期课程吗？
这个子版块里全是第一学期计算机科学专业的学生。
掌握*
我作为一名资深汇编语言程序员进入C语言领域。不知为何，指针和解引用相关的内容让我感到困惑。那些变量前或类型声明后的星号，还有&符号……这是什么情况？后来我意识到，由于在接触高级语言抽象形式之前，我的大脑已经内化了机器语言的机制，因此产生了一种“倒置摩擦”般的认知冲突。我的其他同事也遇到了同样的问题。当我放弃那种自底向上的视角后，C语言的内容逐渐变得自然。有趣的是，后来我又将自底向上的部分重新引入到我的思维中，那种摩擦感却没有再出现。我从未见过那些先学习C语言再学习汇编语言的程序员出现这种情况。非常奇怪。
编辑：修正了变量前后标记的问题
我认为理解这些概念并不难，但识别并解决具体应用场景才是难点。就像他们先教指针和引用再教面向对象一样……而整个重点就是面向对象。
有时候你得学习才能通过驾驶考试。
天啊，这个子版块太烂了，这都是基础知识
等你遇到模板和宏魔法时再回来吧。
我学习时听说过指针，一开始很害怕，但其实没那么糟糕——只是使用时需要多加小心，因为可能存在一些问题。后来还学到了空指针的概念。
在学习了引用、借用和生命周期之后，Rust 程序员们
恭喜你完成了 4 部分教程中的第 2 部分。现在不要放弃
等着学习虚拟内存和指针只是多级哈希映射的事实吧 🙂
这是新手常见的问题。随着经验积累，一切都会豁然开朗。
我猜你还没接触过空指针
我觉得大多数C++开发者在刚接触指针和引用时都用得不好。
哦，太好了，大一新生又回来了
我一直不明白“指针这么难”的幽默。它们其实并不难，而且在很多情况下非常方便
说实话，我一直觉得指针很有趣，直到我遇到了Python。然后我完全讨厌编译了。
为什么这个子版块里的人都在自吹自擂，努力显得比别人更聪明？难道所有程序员都这么油滑吗？
这就是基础
经过数年正确使用它们并考虑堆内存碎片化后。
我学习了一年左右，但仍然不明白
如果你还在学习什么是指针，那你不是开发者，你只是个新手。
C++开发者在学习移动语义和完美转发时。
char const * volatile 令人困惑；
我自学了一晚就学会了，指针怎么会这么难
证明没人懂指针
证明没人懂指针
兄弟，你发帖到最尴尬的子版块来刷 karma。这个梗蠢到离谱。别在 Reddit 刷 karma 了，求求你出去走走吧
额头都有腹肌了
和 rustacean 一样，从 JS 转过来后试图理解生命周期
这太2022了。AI聊天现在会告诉你&和*该放哪里。
大家都说这是基础知识是对的。但我听说过很多关于这个筛选问题的灾难：指针和引用之间的重要区别是什么？
接下来你要说的是互斥锁很难理解。
这就是那种到处都是共享指针的代码。
没关系，孩子，让它超出作用域吧。让岩石管理你的内存，然后在它挂起时抱怨，随意。
不要删除你不懂的那个函数，因为它使用了模板。
将所有变量都声明为静态内联。这并非全局变量，因为它仍在类内部。
这并不难
唉……什么？我在六年级小学就学过指针和引用，当时是个简单的概念，后来更简单了。我认为从编程基础来看，只有安全的并发模式有点复杂。在C++中，高级模板可能更复杂，但即使如此，主要是因为语法（这在概念等中大多已解决）。
否则，我认为只有干净的软件架构、算法、相关数学和物理才是真正复杂的。
不，这是我写出最难以阅读的模板垃圾后的感受，我以为自己智商500，直到第二天再看。指针和引用就是小儿科。
指针很简单，兄弟，我在高中就学过了
你们 seriously，这真的没那么难。如果觉得很难，很可能是因为解释得不够清楚。请寻找其他学习资源！
它们有什么难的，也许我只是看了太多关于旧漏洞的视频或什么的