Are there benefits of passing by pointer over passing by reference in C

Question

What are the benefits of passing by pointer over passing by reference in C     Lately  I have seen a number of examples that chose passing function arguments by pointers instead of passing by reference   Are there benefits to doing this   Example   func SPRITE  x     with a call of  func  amp mySprite     vs   func SPRITE  amp x     with a call of  func mySprite

User · Accepted Answer

A pointer can receive a NULL parameter  a reference parameter can not   If there s ever a chance that you could want to pass  no object   then use a pointer instead of a reference   Also  passing by pointer allows you to explicitly see at the call site whether the object is passed by value or by reference      Is mySprite passed by value or by reference   You can t tell     without looking at the definition of func   func mySprite       func2 passes  by pointer  - no need to look up function definition func2  amp mySprite

User · Answer

Not really   Internally  passing by reference is performed by essentially passing the address of the referenced object   So  there really aren t any efficiency gains to be had by passing a pointer   Passing by reference does have one benefit  however   You are guaranteed to have an instance of whatever object type that is being passed in   If you pass in a pointer  then you run the risk of receiving a NULL pointer   By using pass-by-reference  you are pushing an implicit NULL-check up one level to the caller of your function

User · Answer

Allen Holub s  Enough Rope to Shoot Yourself in the Foot  lists the following 2 rules   120  Reference arguments should always be  const  121  Never use references as outputs  use pointers   He lists several reasons why references were added to C      they are necessary to define copy constructors they are necessary for operator overloads const references allow you to have pass-by-value semantics while avoiding a copy   His main point is that references should not be used as  output  parameters because at the call site there s no indication of whether the parameter is a reference or a value parameter   So his rule is to only use const references as arguments   Personally  I think this is a good rule of thumb as it makes it more clear when a parameter is an output parameter or not   However  while I personally agree with this in general  I do allow myself to be swayed by the opinions of others on my team if they argue for output parameters as references  some developers like them immensely

User · Answer

Clarifications to the preceding posts     References are NOT a guarantee of getting a non-null pointer    Though we often treat them as such    While horrifically bad code  as in take you out behind the woodshed bad code  the following will compile  amp  run    At least under my compiler    bool test  int  amp  a      return   amp a      int    NULL     int main       int   i    int   NULL    cout  lt  lt    test  i     lt  lt  endl         The real issue I have with references lies with other programmers  henceforth termed IDIOTS  who allocate in the constructor  deallocate in the destructor  and fail to supply a copy constructor or operator      Suddenly there s a world of difference between foo BAR bar  and foo BAR  amp  bar     Automatic bitwise copy operation gets invoked   Deallocation in destructor gets invoked twice    Thankfully modern compilers will pick up this double-deallocation of the same pointer   15 years ago  they didn t    Under gcc g    use setenv MALLOC CHECK  0 to revisit the old ways    Resulting  under DEC UNIX  in the same memory being allocated to two different objects   Lots of debugging fun there       More practically    References hide that you are changing data stored someplace else  It s easy to confuse a Reference with a Copied object  Pointers make it obvious

User · Answer

I like the reasoning by an article from  cplusplus com          Pass by value when the function does not want to modify the parameter and the value is easy to copy  ints  doubles  char  bool  etc    simple types  std  string  std  vector  and all other STL containers are NOT simple types     Pass by const pointer when the value is expensive to copy AND the function does not want to modify the value pointed to AND NULL is a valid  expected value that the function handles    Pass by non-const pointer when the value is expensive to copy AND the function wants to modify the value pointed to AND NULL is a valid  expected value that the function handles    Pass by const reference when the value is expensive to copy AND the function does not want to modify the value referred to AND NULL would not be a valid value if a pointer was used instead    Pass by non-cont reference when the value is expensive to copy AND the function wants to modify the value referred to AND NULL would not be a valid value if a pointer was used instead    When writing template functions  there isn t a clear-cut answer because there are a few tradeoffs to consider that are beyond the scope of this discussion  but suffice it to say that most template functions take their parameters by value or  const  reference  however because iterator syntax is similar to that of pointers  asterisk to  dereference    any template function that expects iterators as arguments will also by default accept pointers as well  and not check for NULL since the NULL iterator concept has a different syntax           http   www cplusplus com articles z6vU7k9E    What I take from this is that the major difference between choosing to use a pointer or reference parameter is if NULL is an acceptable value  That s it   Whether the value is input  output  modifiable etc  should be in the documentation   comments about the function  after all

User · Answer

Allen Holub s  Enough Rope to Shoot Yourself in the Foot  lists the following 2 rules   120  Reference arguments should always be  const  121  Never use references as outputs  use pointers   He lists several reasons why references were added to C      they are necessary to define copy constructors they are necessary for operator overloads const references allow you to have pass-by-value semantics while avoiding a copy   His main point is that references should not be used as  output  parameters because at the call site there s no indication of whether the parameter is a reference or a value parameter   So his rule is to only use const references as arguments   Personally  I think this is a good rule of thumb as it makes it more clear when a parameter is an output parameter or not   However  while I personally agree with this in general  I do allow myself to be swayed by the opinions of others on my team if they argue for output parameters as references  some developers like them immensely

User · Answer

Clarifications to the preceding posts     References are NOT a guarantee of getting a non-null pointer    Though we often treat them as such    While horrifically bad code  as in take you out behind the woodshed bad code  the following will compile  amp  run    At least under my compiler    bool test  int  amp  a      return   amp a      int    NULL     int main       int   i    int   NULL    cout  lt  lt    test  i     lt  lt  endl         The real issue I have with references lies with other programmers  henceforth termed IDIOTS  who allocate in the constructor  deallocate in the destructor  and fail to supply a copy constructor or operator      Suddenly there s a world of difference between foo BAR bar  and foo BAR  amp  bar     Automatic bitwise copy operation gets invoked   Deallocation in destructor gets invoked twice    Thankfully modern compilers will pick up this double-deallocation of the same pointer   15 years ago  they didn t    Under gcc g    use setenv MALLOC CHECK  0 to revisit the old ways    Resulting  under DEC UNIX  in the same memory being allocated to two different objects   Lots of debugging fun there       More practically    References hide that you are changing data stored someplace else  It s easy to confuse a Reference with a Copied object  Pointers make it obvious

User · Answer

Most of the answers here fail to address the inherent ambiguity in having a raw pointer in a function signature  in terms of expressing intent  The problems are the following    The caller does not know whether the pointer points to a single objects  or to the start of an  array  of objects  The caller does not know whether the pointer  owns  the memory it points to  IE  whether or not the function should free up the memory   foo new int  - Is this a memory leak    The caller does not know whether or not nullptr can be safely passed into the function    All of these problems are solved by references    References always refer to a single object  References never own the memory they refer to  they are merely a view into memory  References can t be null    This makes references a much better candidate for general use  However  references aren t perfect - there are a couple of major problems to consider    No explicit indirection  This is not a problem with a raw pointer  as we have to use the  amp  operator to show that we are indeed passing a pointer  For example  int a   5  foo a   It is not clear at all here that a is being passed by reference and could be modified   Nullability  This weakness of pointers can also be a strength  when we actually want our references to be nullable  Seeing as std  optional lt T amp  gt  isn t valid  for good reasons   pointers give us that nullability you want    So it seems that when we want a nullable reference with explicit indirection  we should reach for a T  right  Wrong   Abstractions  In our desperation for nullability  we may reach for T   and simply ignore all of the shortcomings and semantic ambiguity listed earlier  Instead  we should reach for what C   does best  an abstraction  If we simply write a class that wraps around a pointer  we gain the expressiveness  as well as the nullability and explicit indirection   template  lt typename T gt  struct optional ref     optional ref     ptr nullptr       optional ref T  t    ptr t       optional ref std  nullptr t    ptr nullptr        T amp  get   const       return  ptr         explicit operator bool   const       return bool ptr        private    T  ptr       This is the most simple interface I could come up with  but it does the job effectively   It allows for initializing the reference  checking whether a value exists and accessing the value  We can use it like so   void foo optional ref lt int gt  x      if  x        auto y   x get           use y here        int x   5  foo  amp x      explicit indirection here foo nullptr      nullability   We have acheived our goals  Let s now see the benefits  in comparison to the raw pointer    The interface shows clearly that the reference should only refer to one object  Clearly it does not own the memory it refers to  as it has no user defined destructor and no method to delete the memory  The caller knows nullptr can be passed in  since the function author explicitly is asking for an optional ref   We could make the interface more complex from here  such as adding equality operators  a monadic get or and map interface  a method that gets the value or throws an exception  constexpr support  That can be done by you   In conclusion  instead of using raw pointers  reason about what those pointers actually mean in your code  and either leverage a standard library abstraction or write your own  This will improve your code significantly

User · Answer

I like the reasoning by an article from  cplusplus com          Pass by value when the function does not want to modify the parameter and the value is easy to copy  ints  doubles  char  bool  etc    simple types  std  string  std  vector  and all other STL containers are NOT simple types     Pass by const pointer when the value is expensive to copy AND the function does not want to modify the value pointed to AND NULL is a valid  expected value that the function handles    Pass by non-const pointer when the value is expensive to copy AND the function wants to modify the value pointed to AND NULL is a valid  expected value that the function handles    Pass by const reference when the value is expensive to copy AND the function does not want to modify the value referred to AND NULL would not be a valid value if a pointer was used instead    Pass by non-cont reference when the value is expensive to copy AND the function wants to modify the value referred to AND NULL would not be a valid value if a pointer was used instead    When writing template functions  there isn t a clear-cut answer because there are a few tradeoffs to consider that are beyond the scope of this discussion  but suffice it to say that most template functions take their parameters by value or  const  reference  however because iterator syntax is similar to that of pointers  asterisk to  dereference    any template function that expects iterators as arguments will also by default accept pointers as well  and not check for NULL since the NULL iterator concept has a different syntax           http   www cplusplus com articles z6vU7k9E    What I take from this is that the major difference between choosing to use a pointer or reference parameter is if NULL is an acceptable value  That s it   Whether the value is input  output  modifiable etc  should be in the documentation   comments about the function  after all

User · Answer

Not really   Internally  passing by reference is performed by essentially passing the address of the referenced object   So  there really aren t any efficiency gains to be had by passing a pointer   Passing by reference does have one benefit  however   You are guaranteed to have an instance of whatever object type that is being passed in   If you pass in a pointer  then you run the risk of receiving a NULL pointer   By using pass-by-reference  you are pushing an implicit NULL-check up one level to the caller of your function

User · Answer

Not really   Internally  passing by reference is performed by essentially passing the address of the referenced object   So  there really aren t any efficiency gains to be had by passing a pointer   Passing by reference does have one benefit  however   You are guaranteed to have an instance of whatever object type that is being passed in   If you pass in a pointer  then you run the risk of receiving a NULL pointer   By using pass-by-reference  you are pushing an implicit NULL-check up one level to the caller of your function

User · Answer

Clarifications to the preceding posts     References are NOT a guarantee of getting a non-null pointer    Though we often treat them as such    While horrifically bad code  as in take you out behind the woodshed bad code  the following will compile  amp  run    At least under my compiler    bool test  int  amp  a      return   amp a      int    NULL     int main       int   i    int   NULL    cout  lt  lt    test  i     lt  lt  endl         The real issue I have with references lies with other programmers  henceforth termed IDIOTS  who allocate in the constructor  deallocate in the destructor  and fail to supply a copy constructor or operator      Suddenly there s a world of difference between foo BAR bar  and foo BAR  amp  bar     Automatic bitwise copy operation gets invoked   Deallocation in destructor gets invoked twice    Thankfully modern compilers will pick up this double-deallocation of the same pointer   15 years ago  they didn t    Under gcc g    use setenv MALLOC CHECK  0 to revisit the old ways    Resulting  under DEC UNIX  in the same memory being allocated to two different objects   Lots of debugging fun there       More practically    References hide that you are changing data stored someplace else  It s easy to confuse a Reference with a Copied object  Pointers make it obvious

User · Answer

Allen Holub s  Enough Rope to Shoot Yourself in the Foot  lists the following 2 rules   120  Reference arguments should always be  const  121  Never use references as outputs  use pointers   He lists several reasons why references were added to C      they are necessary to define copy constructors they are necessary for operator overloads const references allow you to have pass-by-value semantics while avoiding a copy   His main point is that references should not be used as  output  parameters because at the call site there s no indication of whether the parameter is a reference or a value parameter   So his rule is to only use const references as arguments   Personally  I think this is a good rule of thumb as it makes it more clear when a parameter is an output parameter or not   However  while I personally agree with this in general  I do allow myself to be swayed by the opinions of others on my team if they argue for output parameters as references  some developers like them immensely

User · Answer

Allen Holub s  Enough Rope to Shoot Yourself in the Foot  lists the following 2 rules   120  Reference arguments should always be  const  121  Never use references as outputs  use pointers   He lists several reasons why references were added to C      they are necessary to define copy constructors they are necessary for operator overloads const references allow you to have pass-by-value semantics while avoiding a copy   His main point is that references should not be used as  output  parameters because at the call site there s no indication of whether the parameter is a reference or a value parameter   So his rule is to only use const references as arguments   Personally  I think this is a good rule of thumb as it makes it more clear when a parameter is an output parameter or not   However  while I personally agree with this in general  I do allow myself to be swayed by the opinions of others on my team if they argue for output parameters as references  some developers like them immensely

User · Answer

Not really   Internally  passing by reference is performed by essentially passing the address of the referenced object   So  there really aren t any efficiency gains to be had by passing a pointer   Passing by reference does have one benefit  however   You are guaranteed to have an instance of whatever object type that is being passed in   If you pass in a pointer  then you run the risk of receiving a NULL pointer   By using pass-by-reference  you are pushing an implicit NULL-check up one level to the caller of your function

User · Answer

Passing by pointer   Caller has to take the address -  not transparent A 0 value can be provided to mean nothing  This can be used to provide optional arguments    Pass by reference   Caller just passes the object -  transparent  Has to be used for operator overloading  since overloading for pointer types is not possible  pointers are builtin types   So you can t do  string s    amp str1    amp str2  using pointers   No 0 values possible -  Called function doesn t have to check for them Reference to const also accepts temporaries  void f const T amp  t       f T a  b  c     pointers cannot be used like that since you cannot take the address of a temporary  Last but not least  references are easier to use -  less chance for bugs

User · Answer

Passing by pointer   Caller has to take the address -  not transparent A 0 value can be provided to mean nothing  This can be used to provide optional arguments    Pass by reference   Caller just passes the object -  transparent  Has to be used for operator overloading  since overloading for pointer types is not possible  pointers are builtin types   So you can t do  string s    amp str1    amp str2  using pointers   No 0 values possible -  Called function doesn t have to check for them Reference to const also accepts temporaries  void f const T amp  t       f T a  b  c     pointers cannot be used like that since you cannot take the address of a temporary  Last but not least  references are easier to use -  less chance for bugs

User · Answer

Most of the answers here fail to address the inherent ambiguity in having a raw pointer in a function signature  in terms of expressing intent  The problems are the following    The caller does not know whether the pointer points to a single objects  or to the start of an  array  of objects  The caller does not know whether the pointer  owns  the memory it points to  IE  whether or not the function should free up the memory   foo new int  - Is this a memory leak    The caller does not know whether or not nullptr can be safely passed into the function    All of these problems are solved by references    References always refer to a single object  References never own the memory they refer to  they are merely a view into memory  References can t be null    This makes references a much better candidate for general use  However  references aren t perfect - there are a couple of major problems to consider    No explicit indirection  This is not a problem with a raw pointer  as we have to use the  amp  operator to show that we are indeed passing a pointer  For example  int a   5  foo a   It is not clear at all here that a is being passed by reference and could be modified   Nullability  This weakness of pointers can also be a strength  when we actually want our references to be nullable  Seeing as std  optional lt T amp  gt  isn t valid  for good reasons   pointers give us that nullability you want    So it seems that when we want a nullable reference with explicit indirection  we should reach for a T  right  Wrong   Abstractions  In our desperation for nullability  we may reach for T   and simply ignore all of the shortcomings and semantic ambiguity listed earlier  Instead  we should reach for what C   does best  an abstraction  If we simply write a class that wraps around a pointer  we gain the expressiveness  as well as the nullability and explicit indirection   template  lt typename T gt  struct optional ref     optional ref     ptr nullptr       optional ref T  t    ptr t       optional ref std  nullptr t    ptr nullptr        T amp  get   const       return  ptr         explicit operator bool   const       return bool ptr        private    T  ptr       This is the most simple interface I could come up with  but it does the job effectively   It allows for initializing the reference  checking whether a value exists and accessing the value  We can use it like so   void foo optional ref lt int gt  x      if  x        auto y   x get           use y here        int x   5  foo  amp x      explicit indirection here foo nullptr      nullability   We have acheived our goals  Let s now see the benefits  in comparison to the raw pointer    The interface shows clearly that the reference should only refer to one object  Clearly it does not own the memory it refers to  as it has no user defined destructor and no method to delete the memory  The caller knows nullptr can be passed in  since the function author explicitly is asking for an optional ref   We could make the interface more complex from here  such as adding equality operators  a monadic get or and map interface  a method that gets the value or throws an exception  constexpr support  That can be done by you   In conclusion  instead of using raw pointers  reason about what those pointers actually mean in your code  and either leverage a standard library abstraction or write your own  This will improve your code significantly

User · Answer

Clarifications to the preceding posts     References are NOT a guarantee of getting a non-null pointer    Though we often treat them as such    While horrifically bad code  as in take you out behind the woodshed bad code  the following will compile  amp  run    At least under my compiler    bool test  int  amp  a      return   amp a      int    NULL     int main       int   i    int   NULL    cout  lt  lt    test  i     lt  lt  endl         The real issue I have with references lies with other programmers  henceforth termed IDIOTS  who allocate in the constructor  deallocate in the destructor  and fail to supply a copy constructor or operator      Suddenly there s a world of difference between foo BAR bar  and foo BAR  amp  bar     Automatic bitwise copy operation gets invoked   Deallocation in destructor gets invoked twice    Thankfully modern compilers will pick up this double-deallocation of the same pointer   15 years ago  they didn t    Under gcc g    use setenv MALLOC CHECK  0 to revisit the old ways    Resulting  under DEC UNIX  in the same memory being allocated to two different objects   Lots of debugging fun there       More practically    References hide that you are changing data stored someplace else  It s easy to confuse a Reference with a Copied object  Pointers make it obvious

User · Answer

Passing by pointer   Caller has to take the address -  not transparent A 0 value can be provided to mean nothing  This can be used to provide optional arguments    Pass by reference   Caller just passes the object -  transparent  Has to be used for operator overloading  since overloading for pointer types is not possible  pointers are builtin types   So you can t do  string s    amp str1    amp str2  using pointers   No 0 values possible -  Called function doesn t have to check for them Reference to const also accepts temporaries  void f const T amp  t       f T a  b  c     pointers cannot be used like that since you cannot take the address of a temporary  Last but not least  references are easier to use -  less chance for bugs

User · Answer

Passing by pointer   Caller has to take the address -  not transparent A 0 value can be provided to mean nothing  This can be used to provide optional arguments    Pass by reference   Caller just passes the object -  transparent  Has to be used for operator overloading  since overloading for pointer types is not possible  pointers are builtin types   So you can t do  string s    amp str1    amp str2  using pointers   No 0 values possible -  Called function doesn t have to check for them Reference to const also accepts temporaries  void f const T amp  t       f T a  b  c     pointers cannot be used like that since you cannot take the address of a temporary  Last but not least  references are easier to use -  less chance for bugs

[c++] Are there benefits of passing by pointer over passing by reference in C++?

Examples related to c++

Examples related to pointers

Examples related to parameter-passing

Examples related to pass-by-reference