Call of overloaded method with nullptr is ambiguous

Question

I have some overloaed methods which take some different pointer types.
Now I want to call one specific method with nullptr as a parameter.

I know that I could cast the nullptr to the specific type of pointer, the method I want it to call takes.
But I don't want to/can't cast the nullptr.

This example shoud explain what I am trying to do:

class Foo {
    //some attributes
};
class Bar {
    //some attributes
};

void myMethod (Foo*) {
    //I want this method to be called
}
void myMethod (Bar*) {
    //Not this one
}

int main () {
    myMethod(nullptr);              //Something like this
//  myMethod(static_cast<nullptr>); //I don't want to write this.

    return 0;
}

If I just call it with the nullptr I get
error: call of overloaded 'myMethod(std::nullptr_t)' is ambiguous
because the compiler doesn't know which of the methods it should call.

Is there a way to do what I want?
Like something similar to the template specialization?

I forgot about this question and didn't close nor respond to it because the issue was fixed. Turns out I could use `myMethod(static_cast(nullptr));` after all. — Melvin S., Aug 27 '22 at 11:04

score 7 · Answer 1 · answered Aug 28 '18 at 11:00

7

You can create an overload which take std::nullptr_t as argument, and then in it call the exact function wanted (through casting):

void myMethod(std::nullptr_t)
{
    myMethod(static_cast<Foo*>(nullptr));
}

answered Aug 28 '18 at 11:00

Some programmer dude

400,186
35
402
621

would a method w/o parameters be OK too? – Andriy Tylychko Aug 28 '18 at 11:04
@AndriyTylychko That could be used too, but of course depends on the requirements and wishes of the OP. Then a simple default argument like `void myMethod(Foo* = nullptr)` would be sufficient. – Some programmer dude Aug 28 '18 at 11:09

score 5 · Answer 2 · answered Aug 28 '18 at 11:11

You can create pointer of Foo and Bar and let both point to nullptr. Now you can call a overloaded function by passing pointer variable as argument.

class Foo {
    //some attributes
};
class Bar {
    //some attributes
};

void myMethod (Foo*) {
    //I want this method to be called
}
void myMethod (Bar*) {
    //Not this one
}

int main () {
    Foo* foo=nullptr;
    Bar* bar=nullptr;
    myMethod(foo);              //This will call myMethod(Foo*)

    return 0;
}

score 4 · Answer 3 · answered Aug 28 '18 at 11:05

Some programmer dude has a good suggestion, but you could also add a default parameter to one of your methods if you were happy to call it without passing nullptr, like so:

void myMethod (Foo* = nullptr) {}
void myMethod (Bar*) {}

int main () {
    myMethod();
}

score 4 · Answer 4 · answered Aug 28 '18 at 11:22

4

Like something similar to the template specialization?

If that means that you wish to specify the target class on a case by case basis, you can turn the overload in @Some programmer dude's answer into a template.

template<class C>
void myMethod(std::nullptr_t) {
    myMethod(static_cast<C*>(nullptr));
}

Now you can use a simple template name to call the overload you want

myMethod<Foo>(nullptr); // What you want now.
myMethod<Bar>(nullptr); // What you may want at another point.
myMethod<Baz>(nullptr); // What you may want sometime in the future,
                        // after adding another overload.

answered Aug 28 '18 at 11:22

StoryTeller - Unslander Monica

165,132
21
377
458

why pass the `nullptr` if anyhow thats the only allowed value for that overload? I mean `myMethod();` would also do it. Well...might be that there are situations where this makes sense – 463035818_is_not_an_ai Aug 28 '18 at 11:50
@user463035818 - It's not the only allowed value. Common other options include `0`, `NULL`, and probably other integral constant expressions with the value 0. Though I suppose it does look funny. I'll keep it, let it be just one step in refactoring. – StoryTeller - Unslander Monica Aug 28 '18 at 11:52

Call of overloaded method with nullptr is ambiguous

4 Answers4