以下是一些指导方针。

函数使用传递的数据而不修改它:

If the data object is small, such as a built-in data type or a small structure, pass it by value. If the data object is an array, use a pointer because that’s your only choice. Make the pointer a pointer to const. If the data object is a good-sized structure, use a const pointer or a const reference to increase program efficiency.You save the time and space needed to copy a structure or a class design. Make the pointer or reference const. If the data object is a class object, use a const reference.The semantics of class design often require using a reference, which is the main reason C++ added this feature.Thus, the standard way to pass class object arguments is by reference.

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

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

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

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

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

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

“尽可能使用参考文献”规则有问题，如果你想保留参考文献供进一步使用，就会出现这种问题。为了举例说明这一点，假设您有以下类。

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

因此，如果你盲目地坚持引用，你就在传递无效指针的可能性与存储已销毁对象引用的可能性之间进行了权衡，这基本上是相同的效果。

edit:请注意，我坚持了这条规则:“尽可能使用引用，必须使用指针。”避免指针，直到你做不到为止。”这是被点赞最多、接受度最高的答案(其他答案也这么认为)。虽然这应该是显而易见的，但例子并不表明引用是不好的。然而，它们也可能被滥用，就像指针一样，它们也会给代码带来威胁。

指针和引用之间有以下区别。

当涉及到传递变量时，按引用传递看起来像按值传递，但具有指针语义(充当指针)。 引用不能直接初始化为0 (null)。 引用(引用，未引用对象)不能修改(相当于“* const”指针)。 Const引用可以接受临时形参。 局部const引用延长了临时对象的生存期

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

Use references for parameters that will be used locally within a function scope. Use pointers when 0 (null) is acceptable parameter value or you need to store parameter for further use. If 0 (null) is acceptable I am adding "_n" suffix to parameter, use guarded pointer (like QPointer in Qt) or just document it. You can also use smart pointers. You have to be even more careful with shared pointers than with normal pointers (otherwise you can end up with by design memory leaks and responsibility mess).

免责声明:除了引用不能为NULL或“反弹”(意味着它们不能改变它们是别名的对象)这一事实之外，它真的归结为一个品味问题，所以我不会说“这更好”。

也就是说，我不同意你在文章中最后的说法，因为我不认为代码在引用中失去了清晰度。在你的例子中，

add_one(&a);

可能会更清楚

add_one(a);

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

void add_one(int* const n);

也不太清楚n是单个整数还是数组?有时您只能访问(文档记录不佳的)头文件和签名

foo(int* const a, int b);

乍一看不容易理解。

在我看来，当不需要(重新)分配或重新绑定(在前面解释的意义上)时，引用和指针一样好。此外，如果开发人员只对数组使用指针，那么函数签名就不会那么模糊。更不用说使用引用的操作符语法可读性更强了。

任何性能差异都是如此之小，以至于使用不太清楚的方法都是不合理的。

首先，有一种引用通常更好的情况没有提到，那就是const引用。对于非简单类型，传递const引用可以避免创建临时类型，也不会引起您所关心的混乱(因为该值没有被修改)。在这里，强制某人传递指针会导致您所担心的混乱，因为看到地址被获取并传递给函数可能会使您认为值已更改。

无论如何，我基本上同意你的看法。我不喜欢函数接受引用来修改它们的值，而这不是很明显的函数在做什么。在这种情况下，我也更喜欢使用指针。

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

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

在这里，函数名清楚地表明您正在从数组中获取信息。这样就不会混淆了。

引用的主要优点是它们总是包含一个有效值，比指针更简洁，并且支持多态，而不需要任何额外的语法。如果这些优点都不适用，就没有理由更喜欢引用而不是指针。

我的经验法则是:

Use pointers for outgoing or in/out parameters. So it can be seen that the value is going to be changed. (You must use &) Use pointers if NULL parameter is acceptable value. (Make sure it's const if it's an incoming parameter) Use references for incoming parameter if it cannot be NULL and is not a primitive type (const T&). Use pointers or smart pointers when returning a newly created object. Use pointers or smart pointers as struct or class members instead of references. Use references for aliasing (eg. int &current = someArray[i])

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

从 C++ 常见问题精简版 -

Use references when you can, and pointers when you have to. References are usually preferred over pointers whenever you don't need "reseating". This usually means that references are most useful in a class's public interface. References typically appear on the skin of an object, and pointers on the inside. The exception to the above is where a function's parameter or return value needs a "sentinel" reference — a reference that does not refer to an object. This is usually best done by returning/taking a pointer, and giving the NULL pointer this special significance (references must always alias objects, not a dereferenced NULL pointer). Note: Old line C programmers sometimes don't like references since they provide reference semantics that isn't explicit in the caller's code. After some C++ experience, however, one quickly realizes this is a form of information hiding, which is an asset rather than a liability. E.g., programmers should write code in the language of the problem rather than the language of the machine.