“按引用传递”到底是什么意思？意思是？

Question

谁有权力决定？

编辑：显然我没有成功地提出我的问题。
我不是问Java 的参数传递是如何工作的。我知道看起来像保存对象的变量实际上是保存对象引用的变量，并且该引用是按值传递的。 这里（在链接的线程和其他线程中）和其他地方对该机制有很多很好的解释。

问题是关于“按引用传递”一词的技术含义。 （编辑结束）

我不确定这是否是正确的问题，如果不是，抱歉，但我不知道更好的地方。这里的其他问题已经说了很多，例如 Java 是“pass-by-reference”还是“按值传递”？ 和 通过引用传递或传递按值？，但我还没有找到该术语含义的权威答案。

我认为“按引用传递”意味着“将引用（通常是指针）传递给对象”，因此被调用者可以修改调用者看到的对象，而“按值传递”意味着复制对象，并让被调用者享受复制的乐趣（明显的问题：如果对象包含引用、深复制或浅复制怎么办）。
Sing the FW 出现 很多 地点 < a href="http://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_reference" rel="nofollow noreferrer">说“通过引用传递”意味着只是，这里有一些争论认为它意味着更多，但定义仍然是这样的

参数传递模式，其中对实际参数的引用（或者如果你想在政治上不正确，则为指针）被传递到形式参数中；当被调用者需要形式参数时，它会取消引用指针来获取它。

在 this页面，我发现“形参的左值设置为实参的左值”。并且，如果我理解正确的话，这里使用相同的定义（“形式参数仅起作用作为实际参数的别名。”）

事实上，我发现唯一使用更强定义的地方是反对 Java 中对象通过引用传递这一概念的地方（这可能是由于我缺乏 google-fu ）。

按引用传递

class Thing { ... }
void byReference(Thing object){ ... }
Thing something;
byReference(something);

因此，如果我搞清楚了，根据第一个定义的

struct RawThing { ... };
typedef RawThing *Thing;
void byReference(Thing object){
    // do something
}
// ...
struct RawThing whatever = blah();
Thing something = &whatever;
byReference(something); // pass whatever by reference
// we can change the value of what something (the reference to whatever) points to, but not
// where something points to

将大致对应于（在 C 中） ，从这个意义上说，Java 按引用传递对象就足够了。但是根据第二个定义，引用传递或多或少意味着

struct RawThing { ... };
typedef RawThing *RawThingPtr;
typedef RawThingPtr *Thing;
void byReference(Thing object){
    // do something
}
// ...
RawThing whatever = blah();
RawThingPtr thing_pointer = &whatever;
byReference(&thing_pointer); // pass whatever by reference
// now we can not only change the pointed-to (referred) value,
// but also where thing_pointer points to

并且由于Java只允许你拥有指向对象的指针（限制你可以用它们做什么），但没有指针到指针，因为从某种意义上来说，说 Java 通过引用传递对象是完全错误的。

那么，

1. 我是否充分理解了上述引用传递的定义？
2. 还有其他定义吗？
3. 是否就哪个定义是“正确的”达成共识？如果是，那么哪个定义是“正确的”？

Answer 1

当然，目前不同的人对“引用传递”的含义有不同的定义。这就是为什么他们对于某些东西是否是通过引用传递存在分歧的原因。

但是，无论您使用什么定义，都必须在不同语言中一致使用它。你不能说一种语言具有按值传递，并且在另一种语言中具有完全相同的语义并说它是按引用传递。指出语言之间的类比是解决这一争议的最佳方式，因为尽管人们可能对特定语言的传递模式有强烈的看法，但当你将相同的语义与其他语言进行对比时，有时会带来反直觉的结果，迫使他们重新思考他们的定义。

• 一种主要观点是 Java 仅是按值传递的。 （在互联网上到处搜索，你都会找到这种观点。）这种观点是对象不是值，而是总是通过引用进行操作，因此引用是按值分配或传递的。这种观点认为，引用传递的测试是是否可以分配给调用范围内的变量。

如果你同意这一观点，那么你还必须考虑大多数语言，包括 Python、Ruby、OCaml、Scheme、Smalltalk、SML、Go、JavaScript、Objective-C 等多种语言。 仅按值传递。如果您觉得这些内容很奇怪或违反直觉，我要求您指出为什么您认为这些语言中的对象的语义与 Java 中的对象的语义不同。 （我知道其中一些语言可能明确声称它们是按引用传递的；但它们所说的无关紧要；必须根据实际行为将一致的定义应用于所有语言。）

• 如果您采取相反的态度如果认为Java中的对象是按引用传递的，那么您也必须将C视为按引用传递。

以 Java 为例：

class Thing { int x; }
void func(Thing object){ object.x = 42; object = null; }
Thing something = null;
something = new Thing();
func(something);

在 C 中，它相当于：

typedef struct { int x; } Thing;
void func(Thing *object){ object->x = 42; object = NULL; }
Thing *something = NULL;
something = malloc(sizeof Thing);
memset(something, 0, sizeof(something));
func(something);
// later:
free(something);

我声称上面的内容在语义上是等效的；只是语法不同。唯一的语法差异是：

1. C 需要显式的 * 来表示指针类型； Java 的引用（指向对象的指针）类型不需要显式的 *。
2. C使用->通过指针访问字段； Java 只是使用 .
3. Java 使用 new 为堆上的新对象动态分配内存； C使用malloc来分配它，然后我们需要初始化内存。
4. Java 有垃圾收集功能

请注意，重要的是，

1. 使用对象调用函数的语法在两种情况下都是相同的：func(something)，无需执行任何诸如获取地址之类的操作。
2. 在这两种情况下，对象都是动态分配的（它可能超出函数的范围）。并且
3. 在这两种情况下，函数内的 object = null; 不会影响调用范围。

因此，两种情况下的语义是相同的，因此如果您调用 Java 传递引用，则也必须调用 C 传递引用。

Answer 2

谁有权力决定？没有人，也没有人。你自己决定；作家决定他或她的书；读者决定是否同意作者的观点。

要理解这个术语，需要深入了解该语言的底层（用 C 代码来解释它们却没有抓住重点）。参数传递样式是指编译器通常用来创建某些行为的机制。通常定义如下：

• 按值传递：进入子程序时将参数复制到参数中
• 结果传递：进入子程序时参数未定义，在子程序返回时将参数复制到参数中
• 按值传递-result: 在入口处将实参复制到形参中，在返回时将形参复制到返回时的实参
• pass by reference: 将实参变量的引用复制到形参；对参数变量的任何访问都会透明地转换为对参数变量的访问

（术语说明：参数是子例程中定义的变量，参数是调用中使用的表达式。）

教科书通常也定义 pass按名称来说，但这种情况很少见，而且不容易在这里解释。路过的需求也存在。

参数传递风格的重要性在于它的效果：在按值传递时，对参数所做的任何更改都不会传达给实参；在按结果传递中，对参数所做的任何更改都会传达到最后的参数；在按引用传递中，对参数所做的任何更改都会在进行时传达给参数。

有些语言定义了不止一种传递样式，允许程序员分别为每个参数选择他们喜欢的样式。例如，在 Pascal 中，默认样式是按值传递，但程序员可以使用 var 关键字指定按引用传递。其他一些语言指定了一种传球风格。还有一些语言为不同的类型指定不同的样式（例如，在 C 中，默认情况下按值传递，但数组是按引用传递）。

现在，在 Java 中，从技术上讲，我们有一种按值传递的语言，对象变量的值是对该对象的引用。这是否使 Java 在涉及对象变量时采用引用传递是一个品味问题。

Answer 3

您的两个 C 示例实际上都演示了按值传递，因为 C 没有按引用传递。只是您传递的值是一个指针。引用传递发生在 Perl 等语言中：

sub set_to_one($)
{
    $_[0] = 1; # set argument = 1
}
my $a = 0;
set_to_one($a); # equivalent to: $a = 1

这里，变量 $a 实际上是通过引用传递的，因此子例程可以修改它。它不会修改 $a 通过间接指向的某个对象；相反，它修改 $a 本身。

在这方面，Java 与 C 类似，只不过 Java 中的对象是“引用类型”，因此您所拥有的（以及您可以传递的）都是指向它们的指针。像这样的事情：

void setToOne(Integer i)
{
    i = 1; // set argument = 1
}

void foo()
{
    Integer a = 0;
    setToOne(a); // has no effect
}

实际上不会改变a；它只重新分配i。

Answer 4

实际上，通过引用传递是传递对值的引用（而不是它的副本）作为参数。

---

我想在我们继续之前，应该定义某些事情。我使用它们的方式可能与您习惯看到的使用方式不同。

• 对象是一个数据分子。它占用存储空间，并且可能包含其他对象，但有自己的标识，可以作为单个单元引用和使用。

• 引用是对象的别名或句柄。在语言层面，引用的作用大多与它所指代的事物相似。根据语言的不同，编译器/解释器/运行时/gnomes 将在需要实际对象时自动取消引用它。

• 值是计算表达式的结果。它是一个具体的对象，可以存储、传递给函数等。（OOP 专家，请注意，我在这里使用通用“数据分子”意义上的“对象”，而不是 OOP“类实例”意义上的对象。 ）

• 变量是对预分配值的命名引用。

  特别注意：变量不是值。尽管名称不同，变量通常不会改变。它们的价值是变化的。它们如此容易混淆，部分证明了参考错觉通常有多好。

• 引用类型变量（如 Java、C# 等）是一个变量，其值为引用 >.

---

大多数语言，当您将变量作为参数传递时，默认情况下都会创建变量值的副本并传递该副本。被调用者将其参数名称绑定到该副本。这称为“按值传递”（或更清楚地说，“按副本传递”）。调用两侧的两个变量最终具有不同的存储位置，因此是完全不同的变量（仅相关，因为它们通常以相同的值开始）。

另一方面，通过引用传递并不进行复制。相反，它传递变量本身（减去名称）。也就是说，它传递对与变量别名完全相同的值的引用。 （这通常是通过隐式传递指向变量存储的指针来完成的，但这只是一个实现细节；调用者和被调用者不必知道或关心它是如何发生的。）被调用者将其参数的名称绑定到该位置。最终结果是双方使用相同的存储位置（只是名称可能不同）。因此，被调用者对其变量所做的任何更改也会对调用者的变量进行。例如，在面向对象语言的情况下，可以为变量分配完全不同的值。

大多数语言（包括 Java）本身并不支持此功能。哦，他们喜欢说他们这样做......但那是因为那些从未能够真正通过引用传递的人，通常不会理解做与做之间的微妙区别so 并按值传递引用。这些语言中令人困惑的地方在于引用类型变量。 Java 本身从不直接处理引用类型对象，而是处理对这些对象的引用。区别在于“包含”所述对象的变量。引用类型变量的值就是这样的引用（或者，有时，是一个表示“无”的特殊引用值）。当Java传递这样的引用时，虽然它不复制对象，但它仍然复制值（即：函数获取的引用是变量引用的值的副本）。也就是说，它传递引用，但按值传递。这允许通过引用传递允许的大多数事情，但不是全部。

---

我能想到的真正通过引用支持的最明显的测试是“交换测试”。原生支持按引用传递的语言必须提供足够的支持来编写交换其参数值的函数 swap。与此等效的代码：

swap (x, y):       <-- these should be declared as "reference to T"
  temp = x
  x = y
  y = temp

--

value1 = (any valid T)
value2 = (any other valid T)

a = value1
b = value2
swap(a, b)
assert (a == value2 and b == value1)

1. 对于允许复制和重新分配的任何类型 T，必须是可能的并且成功运行，使用语言的赋值和严格相等运算符（包括 T 指定的任何重载）；并且
2. 不得要求调用者转换或“包装”参数（例如：通过显式传递指针）。要求将 args 标记为通过引用传递是可以的。

（显然，没有可变变量的语言无法通过这种方式进行测试——但这没关系，因为它们并不重要。两者之间最大的语义差异在于调用者的可修改程度变量是由被调用者调用的。当变量的值在任何情况下都不可修改时，差异就只是实现细节或优化。）

_{注意，这个答案中的大部分讨论都是关于“变量”的。许多语言（例如 C++）也允许通过引用传递匿名值。机制是一样的；该值占用存储空间，而引用是它的别名。它只是不一定在调用者中具有名称。}

Answer 5

维基百科给出了引用调用的非常明确的定义，我无法改进：

在按引用调用计算（也称为按引用传递）中，函数接收对用作参数的变量的隐式引用，而不是其值的副本。这通常意味着该函数可以修改（即分配给）用作参数的变量 - 其调用者将看到这一点。

请注意，您的两个示例都不是按引用调用，因为在 C 中分配形式参数永远不会修改调用者所看到的参数。

但这已经足够复制粘贴了，请阅读

http://en.wikipedia 上的全面讨论（带有示例） .org/wiki/Evaluation_strategy#Call_by_reference

Answer 6

Java 不通过引用传递。您总是传递副本/按值。但是，如果您传递一个对象，那么您将获得引用的副本。因此，您可以直接编辑对象，但是如果您覆盖本地引用，则原始对象引用将不会被覆盖。

Answer 7

通过引用传递参数意味着参数的指针嵌套比局部变量的指针嵌套更深。如果您有一个具有类类型的变量，则该变量是指向实际值的指针。原始类型的变量包含值本身。

现在，如果按值传递这些变量，则可以保持指针嵌套：对象引用保留指向对象的指针，而基元变量保留值本身。

将变量作为引用传递意味着指针嵌套会更深：将指针传递给对象引用，以便可以更改对象引用；或者传递一个指向原语的指针，以便可以更改其值。

这些定义在 C# 和 Object Pascal 中使用，它们都具有通过引用传递变量的关键字。

回答你的问题：因为最后一个变量 - 第一个示例中的 whatever 和第二个示例中的 thing_pointer - 通过指针传递给函数（& ;)，两者都是通过引用传递的。

Answer 8

如果您熟悉 C，也许下面的类比可以解释 Java 的工作原理。这仅适用于类类型（而不是基本类型）的对象。

在 Java 中，我们可以拥有一个变量并将其传递给函数：

void f(Object x)
{
  x.bar = 5;    // #1j
  x = new Foo;  // #2j
}

void main()
{
  Foo a;
  a.bar = 4;
  f(a);
  // now a.bar == 5
}

在 C 中，这将如下所示：

void f(struct Foo * p)
{
  p->bar = 5;                      // #1c
  p = malloc(sizeof(struct Foo));  // #2c
}

int main()
{
  struct Foo * w = malloc(sizeof(struct Foo));
  w->bar = 4;
  f(w);
  /* now w->bar = 5; */
}

在 Java 中，类类型的变量始终是引用，这在 C 中是最忠实的映射到指针。但在函数调用中，指针本身是通过复制传递的。 访问如 #1j 和 #1c 中的指针会修改原始变量，因此从这个意义上说，您正在传递对该变量的引用。然而，变量本身只是一个指针，它本身是通过复制传递的。所以当你给它分配其他东西时。与 #2j 和 #2c 一样，您只是在 f 的本地范围内重新绑定引用/指针的副本。相应示例中的原始变量 a 或 w 保持不变。

简而言之：一切都是引用，引用是按值传递的。

另一方面，在 C 中，我可以通过声明 void v(struct Foo ** r); 并调用 f(&w) 来实现真正的“按引用传递”代码>;这将允许我从 f 内部更改 w 本身。

注 1：对于像 int 这样的基本类型来说，情况并非如此，它们完全按值传递。

注 2：C++ 示例会更整洁一些，因为我可以通过引用传递指针（而且我不必说 struct）： void f(Foo * & r) { r = 新 Foo; } 和 f(w);。