When to pass by reference and when to pass by pointer in C++?

by

References are easier to get right.

Is your problem with literals that you aren’t using const references? You can’t bind a temporary (produced by a literal) to a non-const reference, because it makes no sense to change one. You can bind one to a const reference.

In particular, when passing an argument to a function, and the function isn’t going to change it, and it isn’t a built-in type, pass by const reference. It works much the same as pass by value, except it doesn’t require a copy constructor call.

Pointers are useful in that they have a guaranteed invalid value you can test for. Sometimes this is irrelevant, and sometimes it’s very important. Of course, you can’t generally pass a literal by pointer, unless (in case of a string literal) it already is.

Some coding standards say that nothing should ever be passed by non-const reference, since it provides no indication at the point of call that the argument might be changed by the function. In that case, you will be required to pass by pointer. I don’t favor this, particularly as programming tools make it easier and easier to get the function signature, so you can see if a function might change an argument. However, when working in a group or for an enterprise, style consistency is more important than any individual style element.

More Related Contents:

  1. Questions regarding constructors
  2. Invalid solution for code challenge with operator restrictions
  3. What does “dereferencing” a pointer mean?
  4. Qt Linker Error: “undefined reference to vtable” [duplicate]
  5. Displaying the #include hierarchy for a C++ file in Visual Studio
  6. Rounding up to the nearest multiple of a number
  7. Using C++ library in C code
  8. Encode/Decode URLs in C++ [closed]
  9. Header guards in C++ and C
  10. c++ template partial specialization member function [duplicate]
  11. Isn’t the template argument (the signature) of std::function part of its type?
  12. Using a STL map of function pointers
  13. The simplest and neatest c++11 ScopeGuard
  14. Using float gives “call to overloaded function is ambiguous” error [duplicate]
  15. Find out whether a C++ object is callable
  16. Why would someone use #define to define constants?
  17. Function Overloading Based on Value vs. Const Reference
  18. Why do we need to use boost::asio::io_service::work?
  19. why reference size is always 4 bytes – c++
  20. How to use graphics.h in codeblocks?
  21. Does boost have a datatype for set operations that is simpler than the STL?
  22. Using `std::function` to call non-void function
  23. Using std::string_view with api that expects null-terminated string
  24. For loop prints an extra comma
  25. CMake: Project structure with unit tests
  26. C++11 std::threads vs posix threads
  27. Mechanism of Vptr and Vtable in C++
  28. Access to method pointer to protected method?
  29. What is the modern, correct way to do type punning in C++?
  30. Why is this C++ wrapper class not being inlined away?

Leave a Comment