关于C#：指针和参考文献之间的真正区别是什么？

What is the real difference between Pointers and References?

AKA - 对指针的这种迷恋是什么？

只使用了ActionScript，Java和C＃这样的现代面向对象语言，我并不真正理解指针的重要性以及它们的用途。我在这里错过了什么？

这一切都只是间接：不处理数据的能力，但说"我会指引你到那里的一些数据"。您在Java和C＃中具有相同的概念，但仅以参考格式。

关键的区别在于引用是有效的不可变路标 - 它们总是指向某些东西。这很有用，也很容易理解，但不如C指针模型灵活。 C指针是你可以愉快地重写的路标。你知道你要找的字符串是指向字符串的隔壁吗？好吧，只是略微改变路标。

这与C的"接近骨头，需要低水平的知识"方法很好地结合。我们知道char* foo由一组从foo路标指向的位置开始的字符组成。如果我们也知道字符串长度至少为10个字符，我们可以将路标更改为(foo + 5)以指向相同的字符串，但是开始的长度的一半。

当你知道你正在做什么时，这种灵活性是有用的，如果你不知道你就知道死亡("知道"不仅仅是"知道语言"，它"知道程序的确切状态")。弄错了，你的路标指引你离开悬崖的边缘。参考文献不会让你弄错，所以你更有信心可以毫无风险地跟随它们(特别是当与"被引用的对象永远不会消失"这样的规则相结合时，就像在大多数垃圾收集的语言中一样)。

你错过了很多！了解计算机如何在较低级别上工作在某些情况下非常有用。 C和汇编程序会为你做这件事。

基本上，一个指针可以让你把东西写到计算机内存中的任何一点。在更原始的硬件/操作系统或嵌入式系统中，这实际上可能会有用。说再次打开和关闭blinkenlichts。

当然，这对现代系统不起作用。操作系统是主存和主存。如果您尝试访问错误的内存位置，您的进程将为其生命中的傲慢付出代价。

在C中，指针是传递对数据的引用的方式。调用函数时，您不希望将百万位复制到堆栈。相反，您只需知道数据驻留在主存储器中的位置。换句话说，您提供指向数据的指针。

在某种程度上，即使使用Java也会发生这种情况。您将引用传递给对象，而不是对象本身。请记住，最终每个对象都是计算机主存中的一组位。

指针用于直接操作内存的内容。

这取决于你是否认为这是一件好事，但它是在C或汇编程序中完成任何事情的基础。

高级语言隐藏了幕后的指针：例如，Java中的引用实现为几乎任何JVM中的指针，这就是为什么它被称为NullPointerException而不是NullReferenceException。但它不会让程序员直接访问它指向的内存地址，并且不能修改它以获取除正确类型的对象的地址之外的值。因此它不能提供与低级语言中的指针相同的功能(和责任)。

[编辑：这是一个问题的答案'对指针的这种迷恋是什么？'。我所比较的只是带有Java引用的汇编程序/ C风格的指针。问题标题后来发生了变化：如果我开始回答我可能提到的除Java之外的其他语言的引用的新问题]

这就像在问，"对CPU指令的这种痴迷是什么？我是不是错过了一些东西，而不是在整个地方撒上x86 MOV指令？"

在低级编程时，您只需要指针。在大多数高级编程语言实现中，指针的使用与C中的一样广泛，但编译器对用户隐藏。

所以......别担心。你已经在使用指针了 - 而且没有做错的危险。 :)

我认为指针是汽车中的手动变速器。如果你学会驾驶带有自动变速器的汽车，那就不会让驾驶员感觉不好。而且你仍然可以完成手动变速器上学到的驾驶员可以做的大部分工作。你的驾驶知识会有一个漏洞。如果你不得不开一本手册，你可能会遇到麻烦。当然，很容易理解它的基本概念，但是一旦你必须做一个小山开始，你就搞砸了。但是，仍然存在手动变速器的地方。例如，赛车驾驶员需要能够转移以使车辆以最佳方式响应当前比赛条件。手动变速器对他们的成功非常重要。

这与现在的编程非常相似。某些软件需要进行C / C ++开发。一些例子是高端3D游戏，低级嵌入式软件，速度是软件目的的关键部分，低级语言允许您更密切地访问需要处理的实际数据，这是该性能的关键。然而，对于大多数程序员而言，情况并非如此，并且不知道指针不会瘫痪。但是，我相信每个人都可以从学习C和指针以及手动传输中受益。

既然您已经使用面向对象语言进行编程，那么我就这样说吧。

您将对象A实例化对象B，并将其作为方法参数传递给对象C.对象C修改对象B中的某些值。当您返回到对象A的代码时，您可以在对象B中看到更改的值。为什么会这样？

因为您将对象B的引用传递给了对象C，所以没有创建对象B的另一个副本。因此，对象A和对象C都在内存中保存对同一对象B的引用。从一个地方改变而在另一个地方看到。这称为参考。

现在，如果您使用原始类型(如int或float)并将它们作为方法参数传递，则对象A无法看到对象C中的更改，因为对象A仅传递副本而不是其自身的变量副本的引用。这称为按值。

你可能已经知道了。

回到C语言，函数A向函数B传递一些变量。这些函数参数是本机副本，按值。为了让函数B操作属于函数A的副本，函数A必须传递一个指向变量的指针，以便它成为一个按引用传递。

"嘿，这是我的整数变量的内存地址。把新值放在那个地址位置，我会稍后再拿。"

注意这个概念是相似的，但不是100％类似的。指针可以做的不仅仅是通过"引用"。指针允许函数将任意位置的内存操作到所需的任何值。指针还用于指向执行代码的新地址，以动态执行任意逻辑，而不仅仅是数据变量。指针甚至可能指向其他指针(双指针)。这很强大，但也很容易引入难以检测的错误和安全漏洞。

从历史上看，使编程成为可能的是实现内存位置可以保存计算机指令，而不仅仅是数据。

指针来自于认识到存储器位置也可以保存其他存储器位置的地址，从而为我们提供了间接性。没有指针(在低级别)，大多数复杂的数据结构是不可能的。没有链表，二进制树或哈希表。没有通过引用传递，只能通过值传递。由于指针可以指向代码，没有它们我们也没有虚函数或函数查找表。

如果你之前没有看过指针，你肯定错过了这个迷你宝石：

1
2
3
4

void strcpy(char *dest, char *src)
{
while(*dest++ = *src++);
}

我在日常工作中大量使用指针和引用...在托管代码(C＃，Java)和非托管代码(C ++，C)中。我学会了如何处理指针以及主人自己的指示...... [Binky !!] [1]没有其他需要说的;)

指针和引用之间的区别是这个。指针是某个内存块的地址。它可以被重写，换句话说，重新分配给其他一些内存块。引用只是重命名某个对象。它只能分配一次！一旦将其分配给对象，就无法将其分配给另一个对象。引用不是地址，它是变量的另一个名称。有关详细信息，请查看C ++ FAQ。

链接1

LINK2

我目前正在设计一些高级企业软件，其中一个或多个其他实体引用了大量数据(存储在SQL数据库中，在这种情况下)。如果没有更多实体引用它时仍然存在大量数据，我们就会浪费存储空间。如果参考指出了那些不存在的数据，那也是一个大问题。

我们的问题和使用指针的语言中的内存管理之间存在着强烈的类比。能够与这些类比的同事交谈是非常有用的。不删除未引用的数据是"内存泄漏"。一个无处可去的引用是一个"悬空指针"。我们可以选择显式的"frees"，或者我们可以使用"引用计数"来实现"垃圾收集"。

因此，理解低级内存管理有助于设计高级应用程序。

在Java中，你一直在使用指针。大多数变量都是指向对象的指针 - 这就是为什么：

1
2
3
4

StringBuffer x = new StringBuffer("Hello");
StringBuffer y = x;
x.append(" boys");
System.out.println(y);

...打印"你好男孩"而不是"你好"。

C中唯一的区别在于添加和减去指针是很常见的 - 如果你弄错了逻辑，你最终可能会搞乱你不应该触及的数据。

C ++中的引用与Java或.NET语言中的引用根本不同; .NET语言具有称为"byrefs"的特殊类型，其行为与C ++"引用"非常相似。

C ++引用或.NET byref(我将使用后一术语来区分.NET引用)是一种特殊类型，它不包含变量，而是保存足以识别变量的信息(或者可以表现的事物)在其他地方举行的，如阵列插槽。 Byref通常仅用作函数参数/参数，并且旨在是短暂的。将byref传递给函数的代码保证了由此识别的变量至少在该函数返回之前存在，并且函数通常保证在返回后不保留byref的任何副本(注意在C ++中后者的限制不是执行)。因此，byrefs不能超过由此识别的变量。

在Java和.NET语言中，引用是一种标识堆对象的类型;每个堆对象都有一个关联的类，堆对象的类中的代码可以访问存储在对象中的数据。堆对象可以授予外部代码对存储在其中的数据的有限或完全访问权限，和/或允许外部代码调用其类中的某些方法。使用对类的方法的引用将使该引用可用于该方法，然后该方法可以使用它来访问堆对象中的数据(甚至是私有数据)。

在Java和.NET语言中引用特殊的是，它们作为绝对不变量维护，只要该引用存在，每个非空引用将继续标识相同的堆对象。一旦在Universe中的任何地方都没有对堆对象的引用，堆对象就会停止存在，但是当对象的任何引用存在时，堆对象就不会停止存在，也没有任何方法可以"正常""引用堆对象以自发地成为除对该对象的引用之外的任何东西。 Java和.NET都有特殊的"弱引用"类型，但即使它们支持不变量。如果Universe中的任何位置都不存在对对象的非弱引用，则任何现有的弱引用都将失效;一旦发生这种情况，就不会有任何对该对象的引用，因此它可以被无效。

指针，如C ++引用和Java / .NET引用，标识对象，但与上述类型的引用不同，它们可以比它们识别的对象更长。如果指针识别的对象不再存在但指针本身不存在，则任何使用指针的尝试都将导致未定义的行为。如果一个指针不知道null或识别一个当前存在的对象，那么除了用其他东西覆盖它之外，没有标准定义的方法可以对该指针做任何事情。如果没有任何东西使用指针，那么指针在被识别的对象停止之后继续存在是完全合法的，但指针外的东西必须指示它是否可以安全使用，因为没有办法问指针本身。

指针和引用(任一类型)之间的关键区别在于，总是可以询问引用它们是否有效(它们是有效的还是可识别为null)，如果被认为是有效的，它们将保持不变，只要它们是存在。不能询问指针是否有效，并且系统不会做任何事情来确保指针不会变得无效，也不会允许无效的指针被识别。

字符串是C(和其他相关语言)的基础。用C编程时，必须管理内存。你不只是说"好吧，我需要一堆字符串";你需要考虑数据结构。你需要多少记忆？你什么时候分配它？你什么时候开始免费？假设你想要10个字符串，每个字符串不超过80个字符。

好的，每个字符串都是一个字符数组(81个字符 - 你一定不要忘记null或者你会后悔！)然后每个字符串本身就是一个数组。最终结果将是一个多维数组

1	char dict[10][81];

顺便提一下，请注意，dict不是"字符串"或"数组"，或"字符"。这是一个指针。当您尝试打印其中一个字符串时，您所做的只是传递单个字符的地址; C假设如果它只是开始打印字符，它最终会达到空值。并且它假设如果你在一个字符串的开头，并且你向前跳转81个字节，那么你将在下一个字符串的开头。实际上，获取指针并向其添加81个字节是跳转到下一个字符串的唯一可能方法。

那么，为什么指针很重要？因为没有它们你就无能为力。你甚至不能做一些简单的事情，比如打印出一堆字符串;你当然不能做任何有趣的事情，如实现链接列表，哈希，队列，树或文件系统，或一些内存管理代码，或内核或......等等。你需要理解它们，因为C只是给你一块内存，让你做其余的事情，用一块原始内存做任何事都需要指针。

此外，许多人认为理解指针的能力与编程技能高度相关。乔尔提出了这个论点，其中包括。例如

Now, I freely admit that programming with pointers is not needed in 90% of the code written today, and in fact, it's downright dangerous in production code. OK. That's fine. And functional programming is just not used much in practice. Agreed.

But it's still important for some of the most exciting programming jobs. Without pointers, for example, you'd never be able to work on the Linux kernel. You can't understand a line of code in Linux, or, indeed, any operating system, without really understanding pointers.

从这里。优秀的文章。

说实话，如果你不知道指针，大多数经验丰富的开发人员会笑(希望友好)。
在我之前的工作中，我们去年有两位新员工(刚刚毕业)，他们不知道指针，仅此一周就是与他们交谈的主题。没有人能够相信如果有人能在不知道指针的情况下毕业......

很长一段时间我都不懂指针，但我理解了数组寻址。所以我通常会为数组中的对象组合一些存储区域，然后使用该数组的索引作为"指针"概念。

1
2
3

SomeObject store[100];
int a_ptr = 20;
SomeObject A = store[a_ptr];

这种方法的一个问题是，在我修改'A'之后，我必须将它重新分配给'store'数组，以便更改是永久性的：

1	store[a_ptr] = A;

在幕后，编程语言正在进行多次复制操作。大多数情况下，这并不影响性能。它主要使代码容易出错且重复。

在我学会理解指针后，我放弃了实现数组寻址方法。这个比喻仍然非常有效。只要考虑'store'数组是由编程语言的运行时管理的。

1
2
3
4

SomeObject A;
SomeObject* a_ptr = &A;
// Any changes to a_ptr's contents hereafter will affect
// the one-true-object that it addresses. No need to reassign.

如今，当我无法合法地复制对象时，我只使用指针。出现这种情况的原因有很多：

避免昂贵的对象复制
操作为了
性能。

其他一些因素不允许
对象复制操作。

你想要一个函数调用
对象的副作用(不要
传递对象，传递指针
于此)。

在某些语言中 - 如果你愿意的话
从a返回多个值
功能(虽然一般
避免)。

用C和C ++等语言编程，你更接近"金属"。指针包含存储位置，您可以在其中存储变量，数据，函数等。您可以传递指针而不是传递值(复制变量和数据)。

使用指针有两件事情很困难：

指针，寻址等指针可能会变得非常神秘。它会导致错误，而且很难阅读。

指针指向的内存通常是从堆中分配的，这意味着您负责释放该内存。您的应用程序越大，越难以满足此要求，并最终导致难以追踪的内存泄漏。

您可以将指针行为与Java对象的传递方式进行比较，但在Java中您不必担心释放内存，因为这是由垃圾收集处理的。通过这种方式，您可以获得有关指针的好处，但不必处理负面因素。如果你不取消引用你的对象，你仍然可以在Java中获得内存泄漏，但这是另一回事。

还有一点需要注意，你可以通过将代码块标记为不安全来使用C＃中的指针(而不是普通引用)。然后你可以直接改变内存地址并做指针算术和所有有趣的东西。它非常适合非常快速的图像处理(我个人使用它的唯一地方)。

据我所知，Java和ActionScript不支持不安全的代码和指针。