Why does std::unique_ptr not permit type inference?

Question

It would be easier to read/write the second line of my example since the type of the template argument is obvious:

#include <memory>

struct Foo{};

int main()
{
  // redundant: good
  auto foo1 = std::unique_ptr<Foo>(new Foo());
  // without explicitness: does not compile
  auto foo2 = std::unique_ptr(new Foo());
}

Of course, if you want to use polymorphism, we could always write:

auto base = std::unique_ptr<Base>(new Derived());

What is the reason for such a constraint?

Answer 1

This is not an issue that's... unique to std::unique_ptr - instantiation of template classes does not automatically deduce the types from the constructors previous to C++17. This is why facilities such as std::make_unique, std::make_pair and std::make_tuple exist: they use template function argument deduction to reduce boilerplate.

---

In C++17 you will be able to write:

auto foo2 = std::unique_ptr(new Foo());

thanks to class template deduction - assuming P0433R0 is accepted, which adds a deduction guide to std::unique_ptr.

The deduction guide is required because std::unique_ptr's constructor that takes a raw pointer uses the pointer type alias which is defined as follows:

std::remove_reference<Deleter>::type::pointer if that type exists, otherwise T*. Must satisfy NullablePointer.

Type aliases like pointer are non-deducible contexts, so P0433R0 proposes the addition of:

template<class T> unique_ptr(T*) 
    -> unique_ptr<T, default_delete<T>>;

template<class T, class V> unique_ptr(T*, V) 
    -> unique_ptr<T, default_delete<T, V>>;  

template<class U, class V> unique_ptr(U, V) 
    -> unique_ptr<typename pointer_traits<typename V::pointer>::element_type, V>;  

Which would enable class template deduction for std::unique_ptr.

Answer 2

The real reason for the absense of the deduction guides is this:

There is no class template argument deduction from pointer type because it is impossible to distinguish a pointer obtained from array and non-array forms of new

Side note: The other answer promised that c++17 will allow this to compile:

This is simply not the case. Also For the above reason.