Templated function can't convert 'int' to nullptr_t

Question

TL;DR:

Why can't templated functions access the same conversions that non-templated functions can?

struct A {
    A(std::nullptr_t) {}
};

template <typename T>
A makeA(T&& arg) {
    return A(std::forward<T>(arg));
}

void foo() {
    A a1(nullptr); //This works, of course
    A a2(0); //This works
    A a3 = makeA(0); //This does not
}

---

Background

I'm trying to write some templated wrapper classes to use around existing types, with the goal of being drop-in replacements with minimal need to rewrite existing code that uses the now-wrapped values.

One particular case I can't get my head around is as follows: we have a class which can be constructed from std::nullptr_t (here called A), and as such, there's plenty of places in the code base where someone has assigned zero to an instance.

However, the wrapper cannot be assigned a zero, despite forwarding the constructors. I have made a very similar example that reproduces the issue without using an actual wrapper class - a simple templated function is sufficient to show the issue.

I would like to allow that syntax of being able to assign zero to continue to be allowed - it isn't my favourite, but minimising friction to moving to newer code is often a necessity just to get people on board with using them.

I also don't want to add a constructor that takes any int other than zero because that's very much absurd, was never allowed before, and it should continue to be caught at compile time.

If such a thing is not possible, it would satisfy me to find an explanation, because with as much as I know so far, it makes no sense to me.

This example has the same behaviour in VC++ (Intellisense seems to be OK with it though...), Clang, and GCC. Ideally a solution will also work in all 3 (4 with intellisense) compilers.

A more directly applicable example is follows:

struct A {
    A(){}
    A(std::nullptr_t) {}
};

template <typename T>
struct Wrapper {
    A a;
    Wrapper(const A& a):a (a) {}

    template <typename T>
    Wrapper(T&& t): a(std::forward<T>(t)){}

    Wrapper(){}
};

void foo2() {
    A a1;
    a1 = 0; // This works

    Wrapper<A> a2;
    a2 = 0; //This does not
}

Answer 1

Why has the compiler decided to treat the zero as an int?

Because it is an integer.

The literal 0 is a literal. Literals get to do funny things. String literals can be converted into const char* or const char[N], where N is the length of the string + NUL terminator. The literal 0 gets to do funny things too; it can be used to initialize a pointer with a NULL pointer constant. And it can be used to initialize an object of type nullptr_t. And of course, it can be used to create an integer.

But once it gets passed as a parameter, it can't be a magical compiler construct anymore. It becomes an actual C++ object with a concrete type. And when it comes to template argument deduction, it gets the most obvious type: int.

Once it becomes an int, it stops being a literal 0 and behaves exactly like any other int. Not unless it is used in a constexpr context (like your int(0)), where the compiler can figure out that it is indeed a literal 0 and therefore can take on its magical properties. Function parameters are never constexpr, and thus they cannot partake in this.