我的经验法则是:

如果你想对指针进行算术运算(例如，增加指针地址以遍历数组)，或者如果你必须传递一个空指针，请使用指针。

否则使用引用。

我真的认为你将受益于建立以下函数调用编码指南:

As in all other places, always be const-correct. Note: This means, among other things, that only out-values (see item 3) and values passed by value (see item 4) can lack the const specifier. Only pass a value by pointer if the value 0/NULL is a valid input in the current context. Rationale 1: As a caller, you see that whatever you pass in must be in a usable state. Rationale 2: As called, you know that whatever comes in is in a usable state. Hence, no NULL-check or error handling needs to be done for that value. Rationale 3: Rationales 1 and 2 will be compiler enforced. Always catch errors at compile time if you can. If a function argument is an out-value, then pass it by reference. Rationale: We don't want to break item 2... Choose "pass by value" over "pass by const reference" only if the value is a POD (Plain old Datastructure) or small enough (memory-wise) or in other ways cheap enough (time-wise) to copy. Rationale: Avoid unnecessary copies. Note: small enough and cheap enough are not absolute measurables.

通过const引用传递，除非有原因你希望改变/保留你传递的内容。

在大多数情况下，这将是最有效的方法。

确保对不想更改的每个形参都使用const，因为这不仅可以防止您在函数中做一些愚蠢的事情，还可以很好地向其他用户指示函数对传入的值做了什么。这包括当你只想改变所指向的对象时，创建一个const指针…

这最终是主观的。到目前为止的讨论是有用的，但我不认为有一个正确或决定性的答案。这在很大程度上取决于风格指南和您当时的需求。

While there are some different capabilities (whether or not something can be NULL) with a pointer, the largest practical difference for an output parameter is purely syntax. Google's C++ Style Guide (https://google.github.io/styleguide/cppguide.html#Reference_Arguments), for example, mandates only pointers for output parameters, and allows only references that are const. The reasoning is one of readability: something with value syntax should not have pointer semantic meaning. I'm not suggesting that this is necessarily right or wrong, but I think the point here is that it's a matter of style, not of correctness.

引用是隐式指针。基本上，你可以改变引用指向的值，但你不能改变引用指向其他东西。因此，我的观点是，如果你只想改变一个参数的值，将其作为引用传递，但如果你需要改变参数以指向一个不同的对象，则使用指针传递它。

如果你要修改变量的值，你应该传递一个指针。 尽管在技术上传递引用或指针是相同的，但在用例中传递指针更具有可读性，因为它“通告”了函数将更改值的事实。

如果你有一个参数，你可能需要指出没有一个值，通常的做法是使参数为指针值并传递NULL。

在大多数情况下(从安全角度来看)，更好的解决方案是使用boost::可选。这允许您通过引用传递可选值，也可以作为返回值。

// Sample method using optional as input parameter
void PrintOptional(const boost::optional<std::string>& optional_str)
{
    if (optional_str)
    {
       cout << *optional_str << std::endl;
    }
    else
    {
       cout << "(no string)" << std::endl;
    }
}

// Sample method using optional as return value
boost::optional<int> ReturnOptional(bool return_nothing)
{
    if (return_nothing)
    {
       return boost::optional<int>();
    }

    return boost::optional<int>(42);
}

考虑一下c#的out关键字。编译器要求方法的调用者将out关键字应用于任何out参数，即使它已经知道它们是否存在。这是为了提高可读性。尽管在现代ide中，我倾向于认为这是语法(或语义)突出显示的工作。

可以时使用引用，必要时使用指针。 来自c++常见问题:“什么时候应该使用引用，什么时候应该使用指针?”

指针:

可以被分配为nullptr(或NULL)。 在调用站点，如果你的类型本身不是指针，你必须使用&， 显式地修改对象。 指针可以被反弹。

引用:

不能为空。 一旦被束缚，就无法改变。 调用者不需要显式地使用&。有时这被认为是 不好，因为你必须去函数的实现看看 完成参数的修改。

指针

A pointer is a variable that holds a memory address. A pointer declaration consists of a base type, an *, and the variable name. A pointer can point to any number of variables in lifetime A pointer that does not currently point to a valid memory location is given the value null (Which is zero) BaseType* ptrBaseType; BaseType objBaseType; ptrBaseType = &objBaseType; The & is a unary operator that returns the memory address of its operand. Dereferencing operator (*) is used to access the value stored in the variable which pointer points to. int nVar = 7; int* ptrVar = &nVar; int nVar2 = *ptrVar;

参考

A reference (&) is like an alias to an existing variable. A reference (&) is like a constant pointer that is automatically dereferenced. It is usually used for function argument lists and function return values. A reference must be initialized when it is created. Once a reference is initialized to an object, it cannot be changed to refer to another object. You cannot have NULL references. A const reference can refer to a const int. It is done with a temporary variable with value of the const int i = 3; //integer declaration int * pi = &i; //pi points to the integer i int& ri = i; //ri is refers to integer i – creation of reference and initialization

引用类似于指针，除了不需要使用前缀*来访问引用所引用的值。同样，在初始化对象之后，不能引用另一个对象。

引用对于指定函数参数特别有用。

有关更多信息，请参阅“Bjarne Stroustrup”(2014)的“c++之旅”(A Tour of c++)第11-12页