What are the advantages of using nullptr?

by

In that code, there doesn’t seem to be an advantage. But consider the following overloaded functions:

void f(char const *ptr);
void f(int v);

f(NULL);  //which function will be called?

Which function will be called? Of course, the intention here is to call f(char const *), but in reality f(int) will be called! That is a big problem1, isn’t it?

So, the solution to such problems is to use nullptr:

f(nullptr); //first function is called

Of course, that is not the only advantage of nullptr. Here is another:

template<typename T, T *ptr>
struct something{};                     //primary template

template<>
struct something<nullptr_t, nullptr>{};  //partial specialization for nullptr

Since in template, the type of nullptr is deduced as nullptr_t, so you can write this:

template<typename T>
void f(T *ptr);   //function to handle non-nullptr argument

void f(nullptr_t); //an overload to handle nullptr argument!!!

1. In C++, NULL is defined as #define NULL 0, so it is basically int, that is why f(int) is called.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. What is move semantics?
  3. What is a lambda expression in C++11?
  4. What are rvalues, lvalues, xvalues, glvalues, and prvalues?
  5. What are the main purposes of using std::forward and which problems it solves?
  6. What exactly is nullptr?
  7. Why should I use a pointer rather than the object itself?
  8. What is “rvalue reference for *this”?
  9. What does T&& (double ampersand) mean in C++11?
  10. C++11 rvalues and move semantics confusion (return statement)
  11. Which kind of pointer do I use when?
  12. What is std::move(), and when should it be used?
  13. NULL vs nullptr (Why was it replaced?) [duplicate]
  14. Does const mean thread-safe in C++11?
  15. How can I efficiently select a Standard Library container in C++11?
  16. Is the safe-bool idiom obsolete in C++11?
  17. Why is `std::move` named `std::move`?
  18. Is the ‘override’ keyword just a check for a overridden virtual method?
  19. c++ access static members using null pointer
  20. Passing shared pointers as arguments
  21. What are the main purposes of std::forward and which problems does it solve?
  22. When do extra parentheses have an effect, other than on operator precedence?
  23. When to make a type non-movable in C++11?
  24. Can nullptr be emulated in gcc?
  25. What is std::move(), and when should it be used and does it actually move anything?
  26. How to pass parameters correctly?
  27. How to parse a date string into a c++11 std::chrono time_point or similar?
  28. Parameter pack must be at the end of the parameter list… When and why?
  29. What is the difference between MinGW, MinGW-w64 and MinGW-builds?
  30. How can I resize a 2D vector of objects given the width and height?

Leave a Comment