在 API 设计中什么时候应该使用指针而不是引用？

Question

我了解指针与引用的语法和一般语义，但我应该如何决定何时在 API 中使用引用或指针或多或少合适？

当然，有些情况需要其中之一（operator++ 需要一个引用参数），但总的来说，我发现我更喜欢使用指针（和 const 指针），因为语法很清楚，变量正在被破坏性地过去了。

例如，在下面的代码中：

void add_one(int& n) { n += 1; }
void add_one(int* const n) { *n += 1; }
int main() {
  int a = 0;
  add_one(a); // Not clear that a may be modified
  add_one(&a); // 'a' is clearly being passed destructively
}

使用指针，发生的事情总是（更）明显，因此对于 API 等，清晰度是一个大问题，指针不是比引用更合适吗？这是否意味着仅应在必要时使用引用（例如 operator++）？其中之一是否存在性能问题？

编辑（已过时）

除了允许 NULL 值和处理原始数组之外，似乎选择取决于个人喜好。我已接受下面引用 Google 的 C++ 风格指南的答案，正如它们所呈现的那样认为“引用可能会令人困惑，因为它们具有值语法但具有指针语义。”。

由于清理不应该为 NULL 的指针参数需要额外的工作（例如 add_one(0) 将调用指针版本并在运行时中断），从可维护性的角度来看，在以下位置使用引用是有意义的：一个对象必须存在，尽管失去语法清晰度是一种耻辱。

Answer 1

尽可能使用引用，并在必要时使用指针。

避免使用指针，除非你不能。

原因是，与任何其他构造相比，指针使事情更难以遵循/阅读、更不安全且危险得多。

因此，经验法则是只有在没有其他选择的情况下才使用指针。

例如，当函数在某些情况下可以返回 nullptr 并且假设它会返回时，返回指向对象的指针是一个有效的选项。也就是说，更好的选择是使用类似于 std::Optional< /code> （需要 C++17；在此之前，有 boost::可选）。

另一个例子是使用指向原始内存的指针来进行特定的内存操作。它应该隐藏并本地化在代码的非常狭窄的部分，以帮助限制整个代码库的危险部分。

在您的示例中，使用指针作为参数是没有意义的，因为：

1. 如果您提供 nullptr 作为参数，您将进入未定义行为领域；
2. 引用属性版本不允许（没有易于发现的技巧）1的问题。
3. 引用属性版本对于用户来说更容易理解：您必须提供一个有效的对象，而不是可能为空的对象。

如果函数的行为必须在有或没有给定对象的情况下工作，那么使用指针作为属性建议您可以传递 nullptr 作为参数，这对于函数来说没问题。这是用户和实现之间的一种合同。

Answer 2

性能完全相同，因为引用在内部实现为指针。因此您无需担心这一点。

关于何时使用引用和指针，没有普遍接受的约定。在某些情况下，您必须返回或接受引用（例如复制构造函数），但除此之外，您可以自由地按照您的意愿进行操作。我遇到的一个相当常见的约定是，当参数必须引用现有对象时使用引用，而当 NULL 值可以时使用指针。

一些编码约定（例如 Google 的）规定应始终使用指针或 const 引用，因为引用有一些不清楚的语法：它们有引用行为但有值语法。

Answer 3

来自 C++ FAQ Lite -

可以时使用引用，必要时使用指针。

当你不需要时，引用通常比指针更受欢迎
“重新就座”。这通常意味着参考文献在
类的公共接口。参考文献通常出现在皮肤上
一个对象，以及内部的指针。

上面的例外是函数的参数或返回值
值需要一个“哨兵”引用——一个不引用的引用
到一个物体。这通常最好通过返回/获取指针来完成，
并赋予 NULL 指针特殊的意义（引用必须
始终为对象别名，而不是取消引用的 NULL 指针）。

注意：老 C 程序员有时不喜欢引用，因为
它们提供调用者中不明确的引用语义
代码。然而，经过一些 C++ 经验之后，人们很快意识到这是
信息隐藏的一种形式，它是一种资产而不是一种
责任。例如，程序员应该用该语言编写代码
问题而不是机器的语言。

Answer 4

我的经验法则是：

• 对传出或输入/输出参数使用指针。所以可以看出这个值是要改变的。 （必须使用 &）
• 如果 NULL 参数是可接受的值，则使用指针。 （如果它是传入参数，请确保它是 const）
• 如果传入参数不能为 NULL 并且不是原始类型 (const T&)，请使用传入参数的引用。
• 返回新创建的对象时使用指针或智能指针。
• 使用指针或智能指针作为结构或类成员而不是引用。
• 使用别名引用（例如int ¤t = someArray[i]）

无论您使用哪一种，如果函数及其参数的含义不明显，请不要忘记记录它们。

Answer 5

免责声明：除了引用不能为 NULL 也不能“反弹”（意味着不能更改它们的别名的对象）这一事实之外，这实际上取决于品味问题，所以我不会说“这样更好”。

也就是说，我不同意您在帖子中的最后一个声明，因为我认为代码不会因为引用而失去清晰度。在您的示例中，

add_one(&a);

可能会更清楚，

add_one(a);

因为您知道 a 的值很可能会发生变化。但另一方面，函数的签名

void add_one(int* const n);

也有些不清楚：n 是单个整数还是数组？有时您只能访问（文档记录很差）标头，并且诸如此类的签名

foo(int* const a, int b);

乍一看并不容易解释。

恕我直言，当不需要（重新）分配或重新绑定（在前面解释的意义上）时，引用与指针一样好。此外，如果开发人员仅使用数组指针，则函数签名就不那么模糊了。更不用说运算符语法通过引用更具可读性。

Answer 6

就像其他人已经回答的那样：始终使用引用，除非 NULL/nullptr 的变量确实是有效状态。

约翰·卡马克对此主题的观点是相似的：

NULL 指针是 C/C++ 中最大的问题，至少在我们的代码中是这样。将单个值同时用作标志和地址会导致数量惊人的致命问题。只要有可能，C++ 引用应该优先于指针；虽然引用“实际上”只是一个指针，但它具有非 NULL 的隐式契约。当指针转换为引用时执行 NULL 检查，然后您可以忽略此问题。

http://www.altdevblogaday.com/2011/12/24/ static-code-analysis/

编辑 2012-03-13

用户 布雷特·库恩斯正确地评论：

C++11 标准已最终确定。我认为是时候在这个线程中提到大多数代码应该在引用、shared_ptr 和 unique_ptr 的组合下表现得非常好。

确实如此，但即使用智能指针替换原始指针，问题仍然存在。

例如，std::unique_ptr 和 std::shared_ptr 都可以通过其默认构造函数构造为“空”指针：

• http://en.cppreference.com/w/cpp/memory/unique_ptr/unique_ptr
• http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr

...意味着使用它们而不需要验证它们不为空可能会导致崩溃，这正是 J. Carmack 讨论的重点。

然后，我们遇到了一个有趣的问题“我们如何将智能指针作为函数参数传递？”

乔恩的答案 对于问题 C++ - 将引用传递给boost::shared_ptr，并且以下注释表明，即使如此，通过复制或通过引用传递智能指针并不像人们希望的那样清晰（我默认情况下喜欢“通过引用”，但是我可能是错的）。

Answer 7

这不是品味问题。以下是一些明确的规则。

如果您想在声明的范围内引用静态声明的变量，请使用 C++ 引用，这将是完全安全的。这同样适用于静态声明的智能指针。通过引用传递参数是这种用法的一个示例。

如果您想引用比声明范围更宽的范围内的任何内容，那么您应该使用引用计数智能指针，以确保它完全安全。

为了语法方便，您可以使用引用来引用集合中的元素，但这并不安全；该元素可以随时删除。

为了安全地保存对集合元素的引用，您必须使用引用计数智能指针。

Answer 8

“尽可能使用引用”规则存在问题，如果您想保留引用以供进一步使用，则会出现此问题。为了用示例来说明这一点，假设您有以下课程。

class SimCard
{
    public:
        explicit SimCard(int id):
            m_id(id)
        {
        }

        int getId() const
        {
            return m_id;
        }

    private:
        int m_id;
};

class RefPhone
{
    public:
        explicit RefPhone(const SimCard & card):
            m_card(card)
        {
        }

        int getSimId()
        {
            return m_card.getId();
        }

    private:
        const SimCard & m_card;
};

乍一看，在 RefPhone(const SimCard & card) 构造函数中通过引用传递参数似乎是个好主意，因为它可以防止将错误/空指针传递给构造函数。它以某种方式鼓励在堆栈上分配变量并从 RAII 中受益。

PtrPhone nullPhone(0);  //this will not happen that easily
SimCard * cardPtr = new SimCard(666);  //evil pointer
delete cardPtr;  //muahaha
PtrPhone uninitPhone(cardPtr);  //this will not happen that easily

但随后，临时的事情就会摧毁你的幸福世界。

RefPhone tempPhone(SimCard(666));   //evil temporary
//function referring to destroyed object
tempPhone.getSimId();    //this can happen

因此，如果您盲目地坚持引用，您就会牺牲传递无效指针的可能性来存储对已销毁对象的引用的可能性，这基本上具有相同的效果。

编辑：请注意，我坚持“尽可能使用引用，必须使用指针。除非不能，否则避免使用指针”。来自最受支持和接受的答案（其他答案也表明如此）。虽然这应该是显而易见的，但例子并不表明引用本身是不好的。然而，它们可能会被滥用，就像指针一样，它们可能会给代码带来威胁。

---

指针和引用之间存在以下差异。

1. 当谈到传递变量时，按引用传递看起来像按值传递，但具有指针语义（就像指针一样）。
2. 引用不能直接初始化为0（空）。
3. Reference（引用，未引用的对象）不可修改（相当于“*const”指针）。
4. const 引用可以接受临时参数。
5. 延长了临时对象的生命周期

本地 const引用 考虑到我目前的规则如下。

• 对将在函数作用域内本地使用的参数使用引用。
• 当 0（空）是可接受的参数值或者需要存储参数以供进一步使用时，请使用指针。如果 0 (null) 可以接受，我将在参数中添加“_n”后缀，使用受保护的指针（如 Qt 中的 QPointer）或只是记录它。您还可以使用智能指针。 与普通指针相比，您必须更加小心地使用共享指针（否则您可能会因设计而导致内存泄漏和责任混乱）。

Answer 9

任何性能差异都非常小，以至于没有理由使用不太明确的方法。

首先，没有提到引用通常更优越的一种情况是 const 引用。对于非简单类型，传递 const 引用 可以避免创建临时变量，也不会导致您担心的混乱（因为该值没有被修改）。在这里，强迫一个人传递指针会导致您担心的混乱，因为看到地址被获取并传递给函数可能会让您认为值发生了变化。

无论如何，我基本上同意你的观点。当函数正在做的事情不是很明显时，我不喜欢函数通过引用来修改它们的值。在这种情况下我也更喜欢使用指针。

当您需要返回复杂类型的值时，我倾向于更喜欢引用。例如：

bool GetFooArray(array &foo); // my preference
bool GetFooArray(array *foo); // alternative

在这里，函数名称清楚地表明您正在数组中获取信息。所以不存在混乱。

引用的主要优点是它们始终包含有效值，比指针更干净，并且支持多态性而不需要任何额外的语法。如果这些优点都不适用，则没有理由更喜欢引用而不是指针。

Answer 10

复制自 wiki-

这样做的结果是，在许多实现中，通过引用对具有自动或静态生存期的变量进行操作，尽管在语法上与直接访问它类似，但可能涉及成本高昂的隐藏取消引用操作。引用是 C++ 语法上有争议的特性，因为它们掩盖了标识符的间接级别。也就是说，与指针通常在语法上很突出的 C 代码不同，在一大块 C++ 代码中，如果正在访问的对象被定义为局部变量或全局变量，或者它是否是对的引用（隐式指针），可能不会立即显而易见。某个其他位置，特别是当代码混合引用和指针时。这方面可能会使写得不好的 C++ 代码更难阅读和调试（请参阅别名）。

我 100% 同意这一点，这就是为什么我认为只有在有充分理由时才应该使用参考文献。

Answer 11

要记住的要点：

1. 指针可以为 NULL，引用不能为 NULL。

2. 引用更容易使用，当我们不想改变值而只需要函数中的引用时，可以使用const作为引用。

3. 指针与 * 一起使用，而引用与 & 一起使用。

4. 当需要进行指针算术运算时使用指针。

5. 您可以拥有指向 void 类型的指针 int a=5; void *p = &a; 但不能拥有对 void 类型的引用。

指针与引用

void fun(int *a)
{
    cout<<a<<'\n'; // address of a = 0x7fff79f83eac
    cout<<*a<<'\n'; // value at a = 5
    cout<<a+1<<'\n'; // address of a increment by 4 bytes(int) = 0x7fff79f83eb0
    cout<<*(a+1)<<'\n'; // value here is by default = 0
}
void fun(int &a)
{
    cout<<a<<'\n'; // reference of original a passed a = 5
}
int a=5;
fun(&a);
fun(a);

判断何时使用什么

指针：用于数组、链接列表、树实现和指针算术。

参考：在函数参数和返回类型中。

Answer 12

以下是一些准则。

函数使用传递的数据而不对其进行修改：

1. 如果数据对象很小，例如内置数据类型或小型结构，则按值传递。

2. 如果数据对象是数组，请使用指针，因为这是您唯一的选择。使指针成为指向 const 的指针。

3. 如果数据对象是一个大小合适的结构，请使用 const 指针或 const
   提高程序效率的参考。您节省了所需的时间和空间
   复制结构或类设计。使指针或引用常量。

4. 如果数据对象是类对象，则使用const引用。类设计的语义常常需要使用引用，这也是C++添加的主要原因
   此功能。因此，传递类对象参数的标准方法是通过引用。

函数修改调用函数中的数据：

1.如果数据对象是内置数据类型，则使用指针。如果你发现代码
就像fixit(&x)一样，其中x是一个int，很明显这个函数打算修改x。

2.如果数据对象是数组，则使用唯一的选择：指针。

3.如果数据对象是结构体，则使用引用或指针。

4.如果数据对象是类对象，则使用引用。

当然，这些只是指导方针，可能有不同的原因
选择。例如，cin 使用基本类型的引用，以便您可以使用 cin >> n
而不是 cin >> &n.

Answer 13

您正确编写的示例应该类似于

void add_one(int& n) { n += 1; }
void add_one(int* const n)
{
  if (n)
    *n += 1;
}

这就是为什么如果可能的话，引用是更好的选择
...

Answer 14

参考文献更清晰、更易于使用，并且可以更好地隐藏信息。
但是，引用不能重新分配。
如果需要先指向一个对象，然后再指向另一个对象，则必须使用指针。引用不能为 null，因此如果存在相关对象可能为 null 的可能性，则不得使用引用。您必须使用指针。
如果您想自己处理对象操作，即如果您想在堆上而不是堆栈上为对象分配内存空间，则必须使用指针

int *pInt = new int; // allocates *pInt on the Heap

Answer 15

在我的实践中，我个人确定了一个简单的规则 - 对可复制/可移动的原语和值使用引用，对具有长生命周期的对象使用指针。

对于 Node 示例，我肯定会使用

AddChild(Node* pNode);

Answer 16

只是投入我的一角钱。我刚刚进行了测试。这是一个偷偷摸摸的人。与使用引用相比，我只是让 g++ 使用指针创建同一小程序的汇编文件。
当查看输出时，它们完全相同。除了符号命名之外。所以看看性能（在一个简单的例子中）是没有问题的。

现在讨论指针与引用的主题。恕我直言，我认为清晰度高于一切。一旦我读到隐性行为，我的脚趾就开始卷曲。我同意引用不能为 NULL 是很好的隐式行为。

取消引用 NULL 指针不是问题。它会让你的应用程序崩溃并且很容易调试。一个更大的问题是未初始化的指针包含无效值。这很可能会导致内存损坏，从而导致没有明确来源的未定义行为。

这就是我认为引用比指针安全得多的地方。我同意之前的说法，即接口（应该清楚地记录下来，请参阅合同设计，Bertrand Meyer）定义函数参数的结果。现在考虑到这一切我的偏好去
尽可能使用参考文献。

Answer 17

对于指针，您需要它们指向某些内容，因此指针会占用内存空间。

例如，采用整数指针的函数将不会采用整数变量。因此，您需要首先创建一个指针以传递给函数。

至于参考，不会耗费内存。您有一个整型变量，可以将其作为引用变量传递。就是这样。您不需要专门为其创建引用变量。