std::unique_ptr constexpr constructors

Question

As shown here, std::unique_ptr has two constexpr constructors for null pointers:

constexpr unique_ptr();
constexpr unique_ptr( nullptr_t );

I have two questions for these two constructors:

1. Why do we need two? Can't we just declare one as:

   constexpr unique_ptr( nullptr_t = nullptr );
   

2. Is the constexpr really useful? I tried doing this in my code but it didn't compile (g++ 6.1.0, -std=c++14):

   constexpr std::unique_ptr<int> p;
   // error: the type 'const std::unique_ptr<int>' of constexpr variable 'p'
   // is not literal because 'std::unique_ptr<int>' has a non-trivial destructor
   

Answer 1

For (1), consider that it ensures that both the no-arg constructor unique_ptr() and null-pointer constructor unique_ptr(nullptr_t) have the same compile-time guarantees, i.e. both are constexpr. We can see the difference in §20.8.1.2:

constexpr unique_ptr() noexcept;
explicit unique_ptr(pointer p) noexcept;
...
constexpr unique_ptr(nullptr_t) noexcept
: unique_ptr() { }

Why the two were not combined into a single constructor with a default value is likely historical contingency.

With regards to (2), why we should care about constexpr despite having a non-trivial destructor, consider the answer given here:

constexpr constructors can be used for constant initialization, which, as a form of static initialization, is guaranteed to happen before any dynamic initialization takes place.

For example, given a global std::mutex:

std::mutex mutex;

In a conforming implementation (read: not MSVC), constructors of other objects can safely lock and unlock mutex, becuase std::mutex's constructor is constexpr.