c++ passing nullptr through multiple functions

Question

I'm having trouble with some code, where I need to pass a pointer through multiple layers of functions. The pointer can be null so I've an overload for the final function for the case of nullptr. Conceptual I've something like this:

void test_ptr(std::nullptr_t)
{
  std::cout << "nullptr" << std::endl;
}
void test_ptr(double *d)
{
  std::cout << *d << std::endl;
}

void test(double *d)
{
  test_ptr(d);
}

int main()
{
  test(nullptr);
}

For me, the ideal behaviour would be, if test calls the first version of test_ptr, but this isn't the case. Is there any chance to manipulate test so that it calls the "right" version?

jrok · Answer 1 · 2014-12-10T12:48:25.790

You'll need a function template:

void test_ptr(std::nullptr_t)
{
  std::cout << "nullptr" << std::endl;
}
void test_ptr(double *d)
{
  std::cout << *d << std::endl;
}

template<typename T>
void test(T d)
{
  test_ptr(d);
}

int main()
{
  test(nullptr);
}

In your code, the argument is double*, regardless from what type it was converted from. A static_assert ensuring that T is a pointer type might also be in order:

static_assert(std::is_pointer<T>{} || std::is_same<T, std::nullptr_t>{},
    "Not a pointer type!");

NOTE: C++14 also introduced std::is_null_pointer.

score 1 · Accepted Answer · edited May 23 '17 at 11:57

1

Why don't you check for nullptr in the beginning of the double* function?

In your case, you do not need to overload the function for nullptr_t. The use of std::nullptr_t is explained in this question: What are the uses of the type `std::nullptr_t`?

So this means for you: If you had another test_ptr function, that accepts a pointer type, then you would need the overloaded one with std::nullptr_t. But with just one test_ptr function, it is not necessary.

edited May 23 '17 at 11:57

Community

1
1

answered Dec 10 '14 at 12:47

MattW

461
3
10

Of course your right that the overload is not necessary but I personally prefer to have to separate cases which should be indicated by two different overloads. Though if I don't get it to work that way, I will implement it as you suggested. – marcel.koch Dec 10 '14 at 13:15

score 1 · Answer 3 · answered Dec 10 '14 at 12:48

After the call to test(nullptr) you have a double* with a value that happens to be null, but the value is a run-time property, its static type is double* and so test_ptr(d) will always choose test_ptr(double*). Overloading chooses a function at compile-time based on types, not based on run-time values.

c++ passing nullptr through multiple functions

3 Answers3