我了解指针与引用的语法和一般语义，但是我应该如何确定何时在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)将在运行时调用指针版本并在运行时中断），因此从可维护性的角度来看，使用必须在存在对象的引用是有意义的，尽管这很遗憾。失去语法清晰度。

尽可能使用引用，必须使用指针。

避免指针，直到不能。

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

因此，经验法则是仅在没有其他选择时才使用指针。

例如，当函数在某些情况下可以返回nullptr且假定会返回时，返回指向对象的指针是有效选项。也就是说，更好的选择是使用类似的东西boost::optional。

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

在您的示例中，使用指针作为参数毫无意义，因为：

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

如果函数的行为必须在有或没有给定对象的情况下都可以使用，则使用指针作为属性建议您可以将其nullptr作为参数传递，这对函数很好。那是用户与实施之间的一种契约。

性能完全相同，因为引用在内部作为指针实现。因此，您不必为此担心。

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

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

从C ++ FAQ精简版 -

尽可能使用引用，而必须使用指针。

每当不需要“重新设置”时，通常比引用更喜欢引用。这通常意味着引用在类的公共接口中最有用。引用通常显示在对象的外观上，而指针则显示在对象的外观上。

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

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

我的经验法则是：

• 将指针用于传出或输入/输出参数。因此可以看出该值将被更改。（您必须使用&）
• 如果NULL参数是可接受的值，请使用指针。（请确保const是传入参数）
• 如果传入参数不能为NULL并且不是基本类型，请使用引用作为参数（const T&），。
• 返回新创建的对象时，请使用指针或智能指针。
• 使用指针或智能指针作为结构或类成员，而不是引用。
• 使用引用进行别名（例如int &current = someArray[i]）

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

免责声明：除了引用不能为NULL或“反弹”（这意味着thay不能更改其别名的对象）的事实外，它还取决于口味，所以我不再赘述“这个更好”。

也就是说，我不同意您在帖子中的最后声明，因为我认为代码不会因引用而变得不清楚。在您的示例中

add_one(&a);

可能比

add_one(a);

因为您知道a的值很可能会改变。另一方面，功能的签名

void add_one(int* const n);

还是不清楚：n是单个整数还是数组？有时，您只能访问（记录不充分的）标题和签名，例如

foo(int* const a, int b);

一见钟情并不容易理解。

恕我直言，当不需要（重新）分配或重新绑定（如前所述）时，引用与指针一样好。此外，如果开发人员仅将指针用于数组，则函数签名的含糊性会降低一些。更不用说运算符语法更易于使用引用阅读的事实。

与其他人一样已经回答了：始终使用引用，除非该变量的存在NULL/ nullptr是真正有效的状态。

约翰·卡马克（John Carmack）在这个问题上的观点是相似的：

NULL指针是C / C ++中最大的问题，至少在我们的代码中是如此。将单个值同时用作标志和地址会导致大量致命问题。尽可能使用C ++引用而不是指针。虽然引用“确实”只是一个指针，但它具有非空的隐式约定。当指针变成引用时执行NULL检查，然后您可以忽略此问题。

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

编辑2012-03-13

用户Bret Kuhns正确地指出：

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讨论的全部内容。

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

乔恩（Jon）对C ++问题的回答-传递对boost :: shared_ptr的引用，以及以下注释表明，即使那样，通过复制或引用传递智能指针也不如人们希望的那样清晰（我喜欢我自己的“默认情况下是按引用”，但我可能错了。

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

如果要在声明范围内引用静态声明的变量，请使用C ++引用，这样绝对安全。静态声明的智能指针也是如此。通过引用传递参数是此用法的一个示例。

如果要引用范围大于声明范围的任何内容，则应使用引用计数的智能指针，以使其完全安全。

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

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

任何性能差异都非常小，以至于无法使用不太清楚的方法来证明其合理性。

首先，没有提到参考通常是优越的情况是const参考。对于非简单类型，传递a const reference可以避免创建临时类型，并且不会引起您担心的混乱（因为未修改值）。在这里，强迫一个人传递一个指针会引起您所担心的混乱，因为看到采用并传递给函数的地址可能会使您认为值已更改。

无论如何，我基本上都同意你的看法。当不太清楚这是函数的作用时，我不喜欢使用引用来修改其值的函数。我也更喜欢在这种情况下使用指针。

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

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

在这里，函数名称使您清楚地知道要以数组形式返回信息。因此，没有混乱。

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

从Wiki复制-

这样做的结果是，在许多实现中，通过引用对具有自动或静态生存期的变量进行操作，尽管其语法与直接访问它的语法相似，但可能涉及昂贵的隐藏取消引用操作。引用是C ++语法上有争议的功能，因为引用使标识符的间接级别变得模糊。也就是说，与通常指针在句法上脱颖而出的C代码不同，在一大段C ++代码中，如果被访问的对象被定义为局部变量或全局变量，或者它是否是对对象的引用（隐式指针），则可能不是立即显而易见的。其他位置，尤其是在代码混合了引用和指针的情况下。这方面会使编写较差的C ++代码更难于阅读和调试（请参阅别名）。

我100％同意这一点，这就是为什么我认为只有在有充分理由的情况下才应使用参考。

注意事项：

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

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

3. 与*while一起使用的指针与一起使用&。

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

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

指针与参考

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);

决定何时使用什么

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

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

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

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. 引用（引用，未引用的对象）不能被修改（相当于“ * const”指针）。
4. const引用可以接受临时参数。
5. 本地const引用延长了临时对象的寿命

考虑到这些因素，我目前的规则如下。

• 将引用用于将在功能范围内本地使用的参数。
• 当可接受的参数值0（空）或需要存储参数以备将来使用时，请使用指针。如果0（空）是可接受的，我在参数中添加“ _n”后缀，请使用受保护的指针（如Qt中的QPointer）或仅对其进行记录。您也可以使用智能指针。使用共享指针必须比使用普通指针更加小心（否则，最终可能会因设计内存泄漏和责任混乱而告终）。

以下是一些准则。

一个函数使用传递的数据而不修改它：

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

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

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

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

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

1.如果数据对象是内置数据类型，请使用指针。如果发现诸如fixit（＆x）之类的代码，其中x是一个整数，则很明显，此函数打算修改x。

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

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

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

当然，这些只是指导原则，可能有做出不同选择的原因。例如，cin使用基本类型的引用，因此您可以使用cin >> n代替cin >>＆n。

引用更干净，更易于使用，并且在隐藏信息方面做得更好。但是，引用不能重新分配。如果需要先指向一个对象，然后再指向另一个对象，则必须使用指针。引用不能为null，因此，如果有问题的对象可能为null的可能性，则不能使用引用。您必须使用一个指针。如果要自己处理对象，即要在堆而不是堆栈上为对象分配内存空间，则必须使用指针

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

您正确编写的示例应如下所示

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

这就是为什么在可能的情况下最好使用引用...

只是放入一角钱。我刚刚进行了测试。那个很时髦。我只是让g ++使用指针而不是使用引用来创建同一小型程序的汇编文件。查看输出时，它们完全相同。除了符号命名。因此，查看性能（在一个简单示例中）没有问题。

现在是关于指针与引用的话题。恕我直言，我认为透明是最重要的。一读到隐性行为，我的脚趾就会开始卷曲。我同意引用不能为NULL是一种很好的隐式行为。

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

我认为这是引用比指针安全得多的地方。我同意先前的说法，即接口（应该清楚地记录在案，请参见按合同设计，Bertrand Meyer）将参数的结果定义为函数。现在考虑到所有这些，我的喜好是尽可能/尽可能使用引用。

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

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

作为参考，它不会消耗内存。您有一个整数变量，可以将其作为参考变量传递。而已。您不需要专门为其创建参考变量。