gsl::not_null vs. std::reference_wrapper vs. T&

by

References are not pointers that cannot be null. References are semantically very different to pointers.

References have value assignment and comparison semantics; that is, assignment or comparison operations involving references read and write the referenced value. Pointers have (counterintuitively) reference assignment and comparison semantics; that is, assignment or comparison operations involving pointers read and write the reference itself (i.e. the address of the referenced object).

As you noted, references cannot be rebound (due to their value assignment semantics), but the reference_wrapper<T> class template can be rebound, because it has reference assignment semantics. This is because reference_wrapper<T> is designed to be used with STL containers and algorithms, and would not behave correctly if its copy assignment operator didn’t do the same thing as its copy constructor. However, reference_wrapper<T> still has value comparison semantics, like a reference, so it behaves very differently to pointers when used with STL containers and algorithms. For example, set<T*> can contain pointers to different objects with the same value, while set<reference_wrapper<T>> can contain a reference to only one object with a given value.

The not_null<T*> class template has reference assignment and comparison semantics, like a pointer; it is a pointer-like type. This means that it behaves like a pointer when used with STL containers and algorithms. It just can’t be null.

So, you are right in your assessment, except you forgot about comparison semantics. And no, reference_wrapper<T> will not be made obsolete by any kind of pointer-like type, because it has reference-like value comparison semantics.

More Related Contents:

  1. What’s the difference between span and array_view in the gsl library?
  2. C++ pointer decleration
  3. Pointer to string with spaces [closed]
  4. What is a smart pointer and when should I use one?
  5. C++ delete – It deletes my objects but I can still access the data?
  6. Why doesn’t polymorphism work without pointers/references?
  7. What is uintptr_t data type
  8. Which kind of pointer do I use when?
  9. C/C++: Pointer Arithmetic
  10. What is the point of function pointers?
  11. What happens in a double delete?
  12. How does delete[] know it’s an array?
  13. Why is ‘this’ a pointer and not a reference?
  14. Modifying a const through a non-const pointer
  15. Why does streaming a char pointer to cout not print an address?
  16. When should I use raw pointers over smart pointers?
  17. Deleting a pointer in C++
  18. Create new C++ object at specific memory address?
  19. Uninitialized pointers in code
  20. Do all pointers have the same size in C++?
  21. can’t modify char* – Memory access violation
  22. c++ delete pointer issue, can still access data [closed]
  23. Why doesn’t reference-to-member exist in C++?
  24. Using a C string gives a warning: “Address of stack memory associated with local variable returned”
  25. Why does pointer to int convert to void* but pointer to function convert to bool?
  26. Get base address of process
  27. Conversion from Derived** to Base**
  28. How to overload operator==() for a pointer to the class?
  29. What does ‘dereferencing’ a pointer mean in C/C++?
  30. Reference to a pointer

Leave a Comment