When to use references vs pointers

Question

I understand the syntax and general semantics of pointers versus references  but how should I decide when it is more-or-less appropriate to use references or pointers in an API   Naturally some situations need one or the other  operator   needs a reference argument   but in general I m finding I prefer to use pointers  and const pointers  as the syntax is clear that the variables are being passed destructively   E g  in the following code   void add one int amp  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  amp a       a  is clearly being passed destructively     With the pointer  it s always  more  obvious what s going on  so for APIs and the like where clarity is a big concern are pointers not more appropriate than references  Does that mean references should only be used when necessary  e g  operator     Are there any performance concerns with one or the other   EDIT  OUTDATED    Besides allowing NULL values and dealing with raw arrays  it seems the choice comes down to personal preference  I ve accepted the answer below that references Google s C   Style Guide  as they present the view that  References can be confusing  as they have value syntax but pointer semantics     Due to the additional work required to sanitise pointer arguments that should not be NULL  e g  add one 0  will call the pointer version and break during runtime   it makes sense from a maintainability perspective to use references where an object MUST be present  though it is a shame to lose the syntactic clarity

User · Answer

In my practice I personally settled down with one simple rule - Use references for primitives and values that are copyable/movable and pointers for objects with long life cycle.

For Node example I would definitely use

AddChild(Node* pNode);

User · Answer

Copied from wiki-     A consequence of this is that in many implementations  operating on a variable with automatic or static lifetime through a reference  although syntactically similar to accessing it directly  can involve hidden dereference operations that are costly  References are a syntactically controversial feature of C   because they obscure an identifier s level of indirection  that is  unlike C code where pointers usually stand out syntactically  in a large block of C   code it may not be immediately obvious if the object being accessed is defined as a local or global variable or whether it is a reference  implicit pointer  to some other location  especially if the code mixes references and pointers  This aspect can make poorly written C   code harder to read and debug  see Aliasing     I agree 100  with this  and this is why I believe that you should only use a reference when you a have very good reason for doing so

User · Answer

From C   FAQ Lite -      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

User · Answer

There is problem with  use references wherever possible  rule and it arises if you want to keep reference for further use  To illustrate this with example  imagine you have following classes   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  amp  card               m card card                               int getSimId                         return m card getId                   private          const SimCard  amp  m card       At first it may seem to be a good idea to have parameter in RefPhone const SimCard  amp  card  constructor passed by a reference  because it prevents passing wrong null pointers to the constructor  It somehow encourages allocation of variables on stack and taking benefits from 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   But then temporaries come to destroy your happy world   RefPhone tempPhone SimCard 666        evil temporary   function referring to destroyed object tempPhone getSimId         this can happen   So if you blindly stick to references you trade off possibility of passing invalid pointers for the possibility of storing references to destroyed objects  which has basically same effect   edit  Note that I sticked to the rule  Use reference wherever you can  pointers wherever you must  Avoid pointers until you can t   from the most upvoted and accepted answer  other answers also suggest so   Though it should be obvious  example is not to show that references as such are bad  They can be misused however  just like pointers and they can bring their own threats to the code     There are following differences between pointers and references    When it comes to passing variables  pass by reference looks like pass by value  but has pointer semantics  acts like pointer                                 Reference can not be directly initialized to 0  null           Reference  reference  not referenced object  can not be modified  equivalent to    const  pointer   const reference can accept temporary parameter  Local const references prolong the lifetime of temporary objects   Taking those into account my current rules are as follows    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

User · Answer

Points to keep in mind    Pointers can be NULL  references cannot be NULL  References are easier to use  const can be used for a reference when we don t want to change value and just need a reference in a function  Pointer used with a   while references used with a  amp   Use pointers when pointer arithmetic operation are required   You can have pointers to a void type int a 5  void  p    amp a  but cannot have a reference to a void type    Pointer Vs Reference  void fun int  a        cout lt  lt a lt  lt   n      address of a   0x7fff79f83eac     cout lt  lt  a lt  lt   n      value at a   5     cout lt  lt a 1 lt  lt   n      address of a increment by 4 bytes int    0x7fff79f83eb0     cout lt  lt   a 1  lt  lt   n      value here is by default   0   void fun int  amp a        cout lt  lt a lt  lt   n      reference of original a passed a   5   int a 5  fun  amp a   fun a     Verdict when to use what  Pointer  For array  linklist  tree implementations and pointer arithmetic   Reference  In function parameters and return types

User · Answer

Any performance difference would be so small that it wouldn t justify using the approach that s less clear   First  one case that wasn t mentioned where references are generally superior is const references  For non-simple types  passing a const reference avoids creating a temporary and doesn t cause the confusion you re concerned about  because the value isn t modified   Here  forcing a person to pass a pointer causes the very confusion you re worried about  as seeing the address taken and passed to a function might make you think the value changed   In any event  I basically agree with you  I don t like functions taking references to modify their value when it s not very obvious that this is what the function is doing  I too prefer to use pointers in that case   When you need to return a value in a complex type  I tend to prefer references  For example   bool GetFooArray array  amp foo      my preference bool GetFooArray array  foo      alternative   Here  the function name makes it clear that you re getting information back in an array  So there s no confusion   The main advantages of references are that they always contain a valid value  are cleaner than pointers  and support polymorphism without needing any extra syntax  If none of these advantages apply  there is no reason to prefer a reference over a pointer

User · Answer

It is not a matter of taste  Here are some definitive rules   If you want to refer to a statically declared variable within the scope in which it was declared then use a C   reference  and it will be perfectly safe  The same applies to a statically declared smart pointer  Passing parameters by reference is an example of this usage   If you want to refer to anything from a scope that is wider than the scope in which it is declared then you should use a reference counted smart pointer for it to be perfectly safe   You can refer to an element of a collection with a reference for syntactic convenience  but it is not safe  the element can be deleted at anytime   To safely hold a reference to an element of a collection you must use a reference counted smart pointer

User · Answer

For pointers  you need them to point to something  so pointers cost memory space   For example a function that takes an integer pointer will not take the integer variable  So you will need to create a pointer for that first to pass on to the function   As for a reference  it will not cost memory  You have an integer variable  and you can pass it as a reference variable  That s it  You don t need to create a reference variable specially for it

User · Answer

Just putting my dime in  I just performed a test  A sneeky one at that  I just let g   create the assembly files of the same mini-program using pointers compared to using references  When looking at the output they are exactly the same  Other than the symbolnaming  So looking at performance  in a simple example  there is no issue   Now on the topic of pointers vs references  IMHO I think clearity stands above all  As soon as I read implicit behaviour my toes start to curl  I agree that it is nice implicit behaviour that a reference cannot be NULL   Dereferencing a NULL pointer is not the problem  it will crash your application and will be easy to debug  A bigger problem is uninitialized pointers containing invalid values  This will most likely result in memory corruption causing undefined behaviour without a clear origin   This is where I think references are much safer than pointers  And I agree with a previous statement  that the interface  which should be clearly documented  see design by contract  Bertrand Meyer  defines the result of the parameters to a function  Now taking this all into consideration my preferences go to  using references wherever whenever possible

User · Answer

You properly written example should look like    void add one int amp  n    n    1    void add one int  const n      if  n       n    1        That s why references are preferable if possible

User · Answer

The performances are exactly the same  as references are implemented internally as pointers  Thus you do not need to worry about that   There is no generally accepted convention regarding when to use references and pointers  In a few cases you have to return or accept references  copy constructor  for instance   but other than that you are free to do as you wish  A rather common convention I ve encountered is to use references when the parameter must refer an existing object and pointers when a NULL value is ok   Some coding convention  like Google s  prescribe that one should always use pointers  or const references  because references have a bit of unclear-syntax  they have reference behaviour but value syntax

User · Answer

The following are some guidelines  A function uses passed data without modifying it   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    A function modifies data in the calling function  1 If the data object is a built-in data type  use a pointer  If you spot code like fixit  amp x   where x is an int  it   s pretty clear that this function intends to modify x  2 If the data object is an array  use your only choice  a pointer  3 If the data object is a structure  use a reference or a pointer  4 If the data object is a class object  use a reference  Of course  these are just guidelines  and there might be reasons for making different choices  For example  cin uses references for basic types so that you can use cin  gt  gt  n instead of cin  gt  gt   amp n

User · Answer

Like others already answered  Always use references  unless the variable being NULL nullptr is really a valid state  John Carmack s viewpoint on the subject is similar   NULL pointers are the biggest problem in C C    at least in our code   The dual use of a single value as both a flag and an address causes an incredible number of fatal issues   C   references should be favored over pointers whenever possible  while a reference is    really    just a pointer  it has the implicit contract of being not-NULL   Perform NULL checks when pointers are turned into references  then you can ignore the issue thereafter   http   www altdevblogaday com 2011 12 24 static-code-analysis  Edit 2012-03-13 User Bret Kuhns rightly remarks   The C  11 standard has been finalized  I think it s time in this thread to mention that most code should do perfectly fine with a combination of references  shared ptr  and unique ptr   True enough  but the question still remains  even when replacing raw pointers with smart pointers  For example  both std  unique ptr and std  shared ptr can be constructed as  quot empty quot  pointers through their default constructor   http   en cppreference com w cpp memory unique ptr unique ptr http   en cppreference com w cpp memory shared ptr shared ptr      meaning that using them without verifying they are not empty risks a crash  which is exactly what J  Carmack s discussion is all about  And then  we have the amusing problem of  quot how do we pass a smart pointer as a function parameter  quot  Jon s answer for the question C   - passing references to boost  shared ptr  and the following comments show that even then  passing a smart pointer by copy or by reference is not as clear cut as one would like  I favor myself the  quot by-reference quot  by default  but I could be wrong

User · Answer

Disclaimer  other than the fact that references cannot be NULL nor  rebound   meaning thay can t change the object they re the alias of   it really comes down to a matter of taste  so I m not going to say  this is better    That said  I disagree with your last statement in the post  in that I don t think the code loses clarity with references  In your example   add one  amp a     might be clearer than  add one a     since you know that most likely the value of a is going to change  On the other hand though  the signature of the function  void add one int  const n     is somewhat not clear either  is n going to be a single integer or an array  Sometimes you only have access to  poorly documentated  headers  and signatures like  foo int  const a  int b     are not easy to interpret at first sight   Imho  references are as good as pointers when no  re allocation nor rebinding  in the sense explained before  is needed  Moreover  if a developer only uses pointers for arrays  functions signatures are somewhat less ambiguous  Not to mention the fact that operators syntax is way more readable with references

User · Answer

Use reference wherever you can  pointers wherever you must  Avoid pointers until you can t  The reason is that pointers make things harder to follow read  less safe and far more dangerous manipulations than any other constructs  So the rule of thumb is to use pointers only if there is no other choice  For example  returning a pointer to an object is a valid option when the function can return nullptr in some cases and it is assumed it will  That said  a better option would be to use something similar to std  optional  requires C  17  before that  there s boost  optional   Another example is to use pointers to raw memory for specific memory manipulations  That should be hidden and localized in very narrow parts of the code  to help limit the dangerous parts of the whole code base  In your example  there is no point in using a pointer as argument because   if you provide nullptr as the argument  you re going in undefined-behaviour-land  the reference attribute version doesn t allow  without easy to spot tricks  the problem with 1  the reference attribute version is simpler to understand for the user  you have to provide a valid object  not something that could be null   If the behaviour of the function would have to work with or without a given object  then using a pointer as attribute suggests that you can pass nullptr as the argument and it is fine for the function  That s kind of a contract between the user and the implementation

User · Answer

References are cleaner and easier to use  and they do a better job of hiding information   References cannot be reassigned  however   If you need to point first to one object and then to another  you must use a pointer  References cannot be null  so if any chance exists that the object in question might be null  you must not use a reference  You must use a pointer   If you want to handle object manipulation on your own i e if you want to allocate memory space for an object on the Heap rather on the Stack you must use Pointer  int  pInt   new int     allocates  pInt on the Heap

User · Answer

My rule of thumb is    Use pointers for outgoing or in out parameters  So it can be seen that the value is going to be changed   You must use  amp   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 amp    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  amp current   someArray i     Regardless which one you use  don t forget to document your functions and the meaning of their parameters if they are not obvious

[c++] When to use references vs. pointers

Examples related to c++

Examples related to pointers

Examples related to reference