0.4.1.1. 比尔·盖茨示例¶

假设函数 A() 和 B() 都执行涉及比尔·盖茨净资产（以十亿美元计）的计算，—是本问题关注的值。 A() 是主函数，它存储初始值（截至 1998 年约为 55）。 A() 调用 B() ，后者尝试将该关注值加 1。

0.4.1.2. 比尔·盖茨 一趟¶

以下是代码及内存示意图，展示了一个简单但不正确的实现，其中 A() 和 B() 采用一趟。代码中标记了三个时间点 T1、T2 和 T3，并展示了每个状态下的内存情况...

void B(int worth) {
  worth = worth + 1;
  // T2
}

void A() {
  int netWorth;
  netWorth = 55;  // T1

  B(netWorth);
  // T3 -- B() did not change netWorth
}

B() 对其局部的 worth 副本加 1，但当 B() 退出时， worth 被释放，因此修改它是无用的。感兴趣的值 netWorth 在整个过程中始终未变地保存在 A() 的局部存储中。函数可以修改其感兴趣值的局部副本，但该修改不会反映回原始值。这实际上只是局部存储旧的“独立性”特性，但在这种情况下并非所需。

0.4.1.3. 按引用¶

比尔盖茨问题的参考解决方案是使用单个 netWorth 变量来存储感兴趣的值，且从不复制它。相反，每个函数可以接收一个指向 netWorth 的指针。每个函数都可以通过解引用其指针来查看 netWorth 的当前值。更重要的是，每个函数只需解引用指向中央 netWorth 的指针并直接修改它，即可改变净 worth—。由于 netWorth 仅存在于一个位置—且每个人都拥有指向该主副本的指针，因此大家对它的当前值达成一致。下面的内存图示展示了改为使用 引用参数 的 A() 和 B() 函数。与之前一样，T1、T2 和 T3 对应代码中的点（如下所示），但您可以在查看代码之前先研究内存结构。

引用参数策略： B() 接收指向目标值的指针，而非副本。

0.4.2.1. 语法¶

C 语言中引用参数的语法仅对参数使用指针操作：

1. 假设一个函数想要传达关于某个感兴趣值的—int 或 float 或 struct fraction 。

2. 该函数将其参数作为指向感兴趣值的指针—一个 int* 或 float* 或 struct fraction* 。有些程序员会在引用参数的名称中添加单词 "ref"，以提醒它是一个指向感兴趣值的引用，而不是副本。

3. 在调用时，调用者计算指向目标值的指针并传递该指针。指针的类型（指向目标值的指针）将与上述 (2) 中的类型一致。如果目标值是调用者的局部变量，则这通常会涉及使用 & 运算符（第 1 节）。

4. 当被调用函数运行时，如果它希望访问目标值，则必须解引用其指针以访问实际的目标值。通常，这相当于在函数中使用解引用运算符 ( * ) 来查看目标值。

0.4.2.2. 比尔·盖茨：按引用传递¶

这是使用引用参数编写的比尔·盖茨示例。此代码现在与上方的按引用内存图相匹配。

     // B() now uses a reference parameter -- a pointer to
     // the value of  interest. B() uses a dereference (*) on the
     // reference parameter to get at the value of interest.
     void B(int* worthRef) {
     // reference parameter
     *worthRef = *worthRef + 1; // use * to get at value of interest
     // T2
     }

     void A() {
     int netWorth;
     netWorth = 55; // T1 -- the value of interest is local to A()
     B(&netWorth);  // Pass a pointer to the value of interest.
                    // In this case using &.
     // T3 -- B() has used its pointer to change the value of interest
}

0.4.2.3. 不要制作副本¶

引用参数使得被调用函数能够与其调用者进行通信。使用引用参数的另一个原因是避免创建副本。出于效率考虑，如果关注的值很大（例如数组），则创建副本可能不可取。创建副本需要额外的空间来存储副本本身，还需要额外的时间来完成复制操作。从设计角度来看，创建副本也可能不可取，因为一旦存在两个副本，若其中任何一个被修改，就无法确定哪一个是“正确”的。谚语云：“拥有一块手表的人总是知道当前时间；拥有两块手表的人却永远无法确定。”应避免创建副本。

0.4.3.1. 交换 () 函数¶

Swap() 相关的值是两个 int 。因此， Swap() 不以 ints 作为其参数。它接受指向 int—（ int* ）的指针。在 Swap() 的主体中，参数 a 和 b 通过 * 解引用，以获取实际的（ int ）关注值。

void Swap(int* a, int* b) {
  int temp;

  temp = *a;
  *a = *b;
  *b = temp;
}

0.4.3.2. 交换 () 调用者¶

要调用 Swap()，调用者必须传递指向感兴趣值的指针。

void SwapCaller() {
  int x = 1;
  int y = 2;

  Swap(&x, &y); // Use & to pass pointers to the int values of interest
                //  (x and y).
}

Swap() 的参数是指向调用者局部变量中感兴趣值的指针。 Swap() 代码可以解引用这些指针以访问调用者的内存并交换值。在这种情况下， Swap() 遵循指针来交换 SwapCaller() 中变量 x 和 y 的值。 Swap() 将交换任意两个整数，只要给出指向这两个整数的指针即可。

0.4.3.3. 使用数组的 Swap()¶

为了说明感兴趣的值不必是简单变量，这里调用 Swap() 来交换数组中第一个和最后一个 int 。 Swap() 接受 int* ，但 ints 可以位于任何位置。数组内的 int 仍然是 int 。

void SwapCaller2() {
  int scores[10];
  scores[0] = 1;
  scores[9[ = 2;
  Swap(&(scores[0]), &(scores[9]));// the ints of interest do not need to be
         // simple variables -- they can be any int. The caller is responsible
         // for computing a pointer to the int.

上述对 Swap() 的调用可以等价地写为 Swap(scores, scores+9) ，这是由于 C 语言中的数组语法。你可以

如果您不熟悉这种情况，请忽略—它并非该语言的重要部分，且两种形式最终都会编译为完全相同的内容。

0.4.4.1. & 符号总是必需的吗？¶

当采用一趟传递时，调用者并不总是需要使用 & 来计算指向目标值的新指针。有时调用者已经拥有指向目标值的指针，因此无需进行新的指针计算。指向目标值的指针可以直接原样传递。

例如，假设 B() 被修改为调用一个 C() 函数，该函数将目标值加 2...

    // Takes the value of interest by reference and adds 2.
    void C(int* worthRef) {
      *worthRef = *worthRef + 2;
    }

    // Adds 1 to the value of interest, and calls C().
    void B(int* worthRef) {
      *worthRef = *worthRef + 1; // add 1 to value of interest as before

      C(worthRef);    // NOTE no & required. We already have
                      // a pointer to the value of interest, so
                      // it can be passed through directly.
}

0.4.4.2. 关于 & Bug 标签页呢？¶

所有这些对 & 的使用可能会让你感到紧张—我们是否犯了第 2 节中的 & 错误？不，事实证明上述对 & 的使用是没问题的。& 错误发生在当 & 将一个指向被调用方局部存储的指针传回给调用方时。当被调用方退出时，其局部内存会被释放，因此该指针不再指向任何对象。在上述正确的情况中，我们使用 & 将指针从调用方传递给被调用方。由于调用方的局部变量在被调用方运行期间仍然存在，该指针对于被调用方来说仍然是有效的。由于一个简单的约束——调用方只能在其被调用方退出之后的某个时刻退出——所指向的对象将保持有效。使用 & 将指向局部存储的指针从调用方传递给被调用方是没问题的。相反的情况，即从被调用方传递到调用方，则是 & 错误。

0.4.4.3. ** 情况¶

如果调用者和被调用者之间需要共享和修改的值本身已经是一个指针，例如 int* 或 struct fraction* ，那会怎样？这会改变设置引用参数的规则吗？不会。在这种情况下，规则没有任何变化。它们的操作方式与之前完全相同。引用参数仍然是指向目标值的指针，即使目标值本身也是一个指针。假设目标值是 int* 。这意味着存在一个 int* 值，调用者和被调用者希望共享并修改它。那么引用参数应该是一个 int** 。对于 struct fraction* 类型的目标值，引用参数是 struct fraction** 。对引用参数执行一次解引用（ * ）操作即可得到目标值，这与简单情况下的处理方式一致。双指针（ ** ）参数在链表或其他操作指针的代码中很常见，其中需要共享和修改的目标值本身就是一个指针，例如链表头指针。