Should I use a pointer or a reference to remotely assign a variable? [duplicate]

Question

This question already has answers here:

How should I pass objects to functions? (8 answers)

When should I use pointers instead of references in API-design? (17 answers)

Closed 2 years ago.

What would be better practice when giving a function the original variable to work with:

unsigned long x = 4;
void func1(unsigned long& val) {
 val = 5; 
}
func1(x);

or:

void func2(unsigned long* val) {
 *val = 5;
}
func2(&x);

IOW: Is there any reason to pick one over another?

• Jay D: References are of course valuable , but i come from C , where pointers are everywhere. One has to be proficient with pointers first to understand the value of references.
• ely: How does this fit in with a goal such as referential transparency from functional programming? What if you always want functions to return new objects and never internally mutate the state, especially not of variables passed to the function. Is there a way this concept is still used with pointers and references in a language like C++. (Note, I'm assuming someone already has the goal of referential transparency. I'm not interested in talking about whether or not it is a good goal to have.)
• Ferruccio: Prefer references. User pointers when you don't have a choice.

Answer 1

My rule of thumb is:

Use pointers if you want to do pointer arithmetic with them (e.g. incrementing the pointer address to step through an array) or if you ever have to pass a NULL-pointer.

Use references otherwise.

• Richard Corden: Excelent point regarding a pointer being NULL. If you have a pointer parameter then you must either check explicitly that it is not NULL, or search all usages of the function to be sure that it is never NULL. This effort is not required for references.
• Loki Astari: Explain what you mean by arithmetic. A new user may not understand that you want to adjust what the pointer is pointing at.
• Nils Pipenbrinck: Martin, By arithmetic I mean that you pass a pointer to a structure but know that it's not a simple structure but an array of it. In this case you could either index it using [] or do arithmetic by using ++/-- on the pointer. That's the difference in a nutshell.
• Nils Pipenbrinck: Martin, You can only do this with pointers directly. Not with references. Sure you can take a pointer to a reference and do the same thing in practice, but if you do so you end with very dirty code..
• Chris Redford: What about polymorphism (e.g. Base* b = new Derived())? This seems like a case that can't be handled without pointers.

Answer 2

I really think you will benefit from establishing the following function calling coding guidelines:

1. 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.

2. 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.

3. If a function argument is an out-value, then pass it by reference.

   • Rationale: We don't want to break item 2...

4. 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.

• paercebal: It lacks the guideline when:... "when to use const &"... The guideline 2 should be written "for [in] values, only pass by pointer if NULL is valid. Otherwise, use const reference (or for "small" objects, copy), or reference if it is an [out] value. I'm monitoring this post to potentially add a +1.
• Johann Gerell: Item 1 covers the case you describe.
• MSalters: It's a bit hard to pass an out-parameter by reference if it's not default-constructible. That's quite common in my code - the whole reason to have a function create that out-object is because it's non-trivial.
• Kleist: @MSalters: If you're going to allocate the memory inside the function (which I think is what you mean), then why not just return a pointer to the allocated memory?
• Johann Gerell: @Kleist: On behalf of @MSalters, there are many possible reasons. One is that you might already have allocated memory to fill, like a pre-sized std::vector<>.

Answer 3

This ultimately ends up being subjective. The discussion thus far is useful, but I don't think there is a correct or decisive answer to this. A lot will depend on style guidelines and your needs at the time.

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.

• Eric Andrew Lewis: What does it mean that references have value syntax but pointer semantic meaning?
• phant0m: It looks like you are passing a copy since the "pass by reference" part is only apparent from the funciton definition (value syntax), but you're not copying the value you pass, you essentially pass a pointer under the hood, which allows the function to modify your value.
• Deduplicator: One should not forget that the Google C++ style guide is much detested.

Answer 4

Pointers

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

Reference

• 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
  

enter image description here

enter image description here

• Ikem Krueger: I liked your comparision table. I noticed a little typo on the second line: "Pointer can be initialised at any time".

Answer 5

You should pass a pointer if you are going to modify the value of the variable. Even though technically passing a reference or a pointer are the same, passing a pointer in your use case is more readable as it "advertises" the fact that the value will be changed by the function.

• Alexander Kondratskiy: If you follow Johann Gerell guidelines, a non-const reference also advertises a changeable variable, so the pointer does not have that advantage here.
• Tony Delroy: @AlexanderKondratskiy: you're missing the point... you can't see instantly at the call site whether the called function accepts a paramter as a const or non-const reference, but you can see if the parameter's passed ala &x vs. x, and use that convension to encode whether the parameter's liable to be modified. (That said, there are times when you'll want to pass a const pointer, so the convension's just a hint. Arguable suspecting something might be modified when it won't be is less dangerous than thinking it won't be when it will be....)

Answer 6

Use a reference when you can, use a pointer when you have to. From C++ FAQ: "When should I use references, and when should I use pointers?"

Answer 7

If you have a parameter where you may need to indicate the absence of a value, it's common practice to make the parameter a pointer value and pass in NULL.

A better solution in most cases (from a safety perspective) is to use boost::optional. This allows you to pass in optional values by reference and also as a return value.

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

Answer 8

A reference is an implicit pointer. Basically you can change the value the reference points to but you can't change the reference to point to something else. So my 2 cents is that if you only want to change the value of a parameter pass it as a reference but if you need to change the parameter to point to a different object pass it using a pointer.

Answer 9

Consider C#'s out keyword. The compiler requires the caller of a method to apply the out keyword to any out args, even though it knows already if they are. This is intended to enhance readability. Although with modern IDEs I'm inclined to think that this is a job for syntax (or semantic) highlighting.

• peenut: typo: semantic, not symantic; +1 I agree about possibility of highlighting instead of writing out (C#), or & (in case of C, no references)

Answer 10

Pass by const reference unless there is a reason you wish to change/keep the contents you are passing in.

This will be the most efficient method in most cases.

Make sure you use const on each parameter you do not wish to change, as this not only protects you from doing something stupid in the function, it gives a good indication to other users what the function does to the passed in values. This includes making a pointer const when you only want to change whats pointed to...

Answer 11

Pointers:

• Can be assigned nullptr (or NULL).
• At the call site, you must use & if your type is not a pointer itself, making explicitly you are modifying your object.
• Pointers can be rebound.

References:

• Cannot be null.
• Once bound, cannot change.
• Callers don't need to explicitly use &. This is considered sometimes bad because you must go to the implementation of the function to see if your parameter is modified.

• Serguei Fedorov: A small point to those who do not know: nullptr or NULL is simply a 0. stackoverflow.com/questions/462165/…
• Johan Lundberg: nullptr is not the same as 0. Try int a=nullptr; stackoverflow.com/questions/1282295/what-exactly-is-nullptr

Answer 12

A reference is similar to a pointer, except that you don’t need to use a prefix ∗ to access the value referred to by the reference. Also, a reference cannot be made to refer to a different object after its initialization.

References are particularly useful for specifying function arguments.

for more information see "A Tour of C++" by "Bjarne Stroustrup" (2014) Pages 11-12