Avoid non-const references

[I know this is in the Google style guide, consider this another version of the same argument.]

In general, arguments should be values, const references, or pointers, _not_ bare references. Why?

Well, you might write a function inc which increments an int.

  void inc(int& i)
  {
     ++i;
  }

which would then be called in someone's code like this:

    int i = 0;
    foo(i,i+1);
    bar(i);
    inc(i);
    baz(i);

The reader of that code doesn't have any reason to assume that i has any value other than zero, unless they know about the implementation of inc. But, you say, they should be able to read my excellent function names, and understand that “inc” is short for “increment”. But consider the next person to read this code: they have a lot on their mind, a lot to understand, and they're probably looking for a bug, so may be extra suspicious of your lovely code.

So do this: even for this innocuous incrementer, declare it so:

  void inc(int* i)
  {
     ++*i;
  }

and then when the read the code at the call site, a big ugly ampersand tells them someone may have messed with their i:

    int i = 0;
    foo(i,i+1);
    bar(i);
    inc(&i);
    baz(i);

But...

If your function is more complex than inc, and you believe the code is more readable with the reference, just capture the argument locally. And don't be such a baby.

void set_first_element_to_one_if_has_at_least_one_elemet(std::vector<int>* pv)
{
  if (pv->size() == 0) return;
  (*pv)[0] = 1;  // Don't like this?
  auto& v = *pv;
  v[0] = 1; // Look, much nicer
}