Why does C++ not attempt to use the second template overload?

Question

I was implementing a simple smart pointer class, and I decided I wanted to make my own versions of the std::make_unique / std::make_shared functions to go along with it once I finished. I created these two overloads:

// note: Box is my "unique pointer" type, it has a partial specialization for T[],
// and it works as expected when created outside of these functions

template  Box make_box(Args &&... args) {
  auto ptr = new T(std::forward(args)...);

  return Box(std::move(ptr));
}

template  Box make_box(std::size_t size) {
  auto ptr = new std::remove_extent_t[size];

  return Box(std::move(ptr));
}

The first overload works just fine, at least in this example:

struct Point3D {
  double x, y, z;

  Point3D() = default;

  Point3D(double x, double y, double z) : x{x}, y{y}, z{z} {};
};

// works exactly as expected, Box is created and does what it's supposed to
auto box = make_box(1.0, 2.0, 3.0);

However, the overload for arrays doesn't seem to be used. If I try to call it with an array type as T, the program won't compile. The following code gives me an error while attempting to use the first overload, and doesn't even attempt to use the second one:

// Gives an error about "allocation of incomplete type 'Point3D []' 
// from inside a template instantiation of 'make_box'.
// the overload with one template parameter isn't used
auto box = make_box(20);

// Note that this works fine, and uses the Box specialization that calls delete[]: 
Box boxed(new Point3D[20]);

What is the reason for this? The two overloads seem effectively identical to the implementations of std::make_unique inside LLVM's libc++ and GNU's libstdc++. It does it on multiple compilers as well (tested with GCC 10.1 and Clang 10.0.1, both compiled with -std=c++17 -Wall -Wextra -pedantic).

Edit: Definition(s) for the Box class:

template  class Box {
  T *m_ptr;

public:
  explicit Box(T *&&ptr) : m_ptr{ptr} {}

  Box() = delete;

  Box(const Box &) = delete;

  Box(Box &&other) : m_ptr{other.m_ptr} {}

  ~Box() { delete m_ptr; }

  T &operator*() const { return *m_ptr; }

  T *operator->() const { return m_ptr; }
};

template  class Box {
  T *m_ptr;

public:
  explicit Box(T *&&ptr) : m_ptr{ptr} {}

  Box() = delete;

  Box(const Box &) = delete;

  Box(Box &&other) : m_ptr{other.m_ptr} {}

  ~Box() { delete[] m_ptr; }

  T &operator*() const { return *m_ptr; }

  T *operator->() const { return m_ptr; }

  T &operator[](std::size_t idx) { return m_ptr[idx]; }
};

user_1678770 · Answer

"Forwarding reference" deduced template type arguments are greedy, which is interfering with your overload resolution.

When you call:

auto box = make_box(20);

This is actually calling make_box with T = Point32[] and Args = int -- which is unambiguously resolved as a better overload than calling make_box(std::size_t). This is due to the fact that 20 is a PR-value of an int, which requires a conversion to std::size_t to be an accurate match for the second overload. Since overload resolution will always prefer to choose the overload that requires no conversions, it selects the first overload.

The fix for this would be to use SFINAE to prevent the Args... overload from being selected when T is an array type. This is what is done for std::make_unique in order to choose between a T[] and T type. The way that std::make_unique is commonly implemented is by SFINAE-detecting when T is a scalar, bounded array, or an unbounded array type, and presenting overloads accordingly.

Using this approach, your code could be rewritten as:

  namespace detail {
    template 
    struct make_box_result
    {
      using object = T;
    };
    template 
    struct make_box_result
    {
      using unbounded_array = T[];
    };
    template 
    struct make_box_result
    {
      using bounded_array = T[N];
    };
  }

  // Only enable 'Args...' overload for non-array types
  template 
  Box::object>
    make_box(Args&&...args);

  // Only enable 'size_t' overload for array types (unbounded arrays).
  // Prevents the greedy lookup
  template 
  Box::unbounded_array>
    make_box(std::size_t size);

  // Disabled for fixed types
  template 
  Box::bounded_array>
    make_box() = delete;

There are other ways that you can SFINAE-prevent this from occurring; I just use this approach as an example since it also prevents T[N] from being specified.

user_501250 · Answer

20 is an int literal, not an std::size_t literal. This means that the first overload is preferred, as no conversion is required. You can force the type like so, and then it works:

auto box = make_box(std::size_t{20});

Overloading in this way, you will also never be able to call make_box() on a type whose constructor takes a single std::size_t because the second form will be preferred and the whole thing will fall over.

You can fix both of these issues by enabling each function appropriately depending on whether T refers to an array type:

template 
std::enable_if_t, Box> make_box(Args &&... args) {
  auto ptr = new T(std::forward(args)...);

  return Box(std::move(ptr));
}

template 
std::enable_if_t, Box> make_box(std::size_t size) {
  auto ptr = new std::remove_extent_t[size];

  return Box(std::move(ptr));
}

This technique would allow you to implement another overload for array types, taking the array elements directly as arguments (though you would run into the same pitfall if calling make_box(10) -- this would create an array of 10 elements, where the intent could be to create an array with 1 element equal to 10):

template 
std::enable_if_t, Box> make_box(Args && ... values) {
  auto ptr = new std::remove_extent_t[sizeof...(values)] { std::forward(values)... };

  return Box(std::move(ptr));
}

user_775806 · Answer

The problem is with your std::size parameter. 20 is of type int, so this call involves a conversion. The first overload is a perfect match.

make_box(static_cast(20))

would work but of course nobody wants to type that.

You may want to SFINAE out array types from the first overload.

template  
     auto make_box(Args &&... args) -> 
         std::enable_if_t, Box>

Why does C++ not attempt to use the second template overload?

3 Answers