Merge pull request #338 from elbeno/array-zero-case

🐛 Fix `make_array` for zero-length cases

Author: elbeno

include/stdx/array.hpp

@@ -11,6 +11,8 @@ template <typename D = void, typename... Ts>
 constexpr auto make_array(Ts &&...ts) {
     if constexpr (not std::is_void_v<D>) {
         return std::array<D, sizeof...(Ts)>{std::forward<Ts>(ts)...};
+    } else if constexpr (sizeof...(Ts) == 0) {
+        return std::array<int, 0>{};
     } else {
         using A = std::common_type_t<Ts...>;
         return std::array<A, sizeof...(Ts)>{std::forward<Ts>(ts)...};
@@ -19,7 +21,7 @@ constexpr auto make_array(Ts &&...ts) {
 
 template <template <auto> typename D, typename T, T... Is>
 constexpr auto make_array(std::integer_sequence<T, Is...>) {
-    using A = std::common_type_t<decltype(D<Is>::value)...>;
+    using A = std::remove_const_t<decltype(D<T{}>::value)>;
     return std::array<A, sizeof...(Is)>{D<Is>::value...};
 }
 
@@ -29,7 +31,7 @@ template <template <auto> typename D, auto N> constexpr auto make_array() {
 
 template <typename T, T... Is, typename F>
 constexpr auto make_array(std::integer_sequence<T, Is...>, F &&f) {
-    using A = std::common_type_t<decltype(f.template operator()<Is>())...>;
+    using A = std::remove_const_t<decltype(f.template operator()<T{}>())>;
     return std::array<A, sizeof...(Is)>{f.template operator()<Is>()...};
 }
 

test/array.cpp

@@ -10,6 +10,16 @@ TEST_CASE("make_array (variadic arguments)", "[array]") {
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array (zero case)", "[array]") {
+    auto arr = stdx::make_array<float>();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<float, 0>>);
+}
+
+TEST_CASE("make_array (zero case default)", "[array]") {
+    auto arr = stdx::make_array();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 namespace {
 template <auto I> using V = std::integral_constant<decltype(I), I + 1>;
 }
@@ -20,12 +30,24 @@ TEST_CASE("make_array by sequence (template with ::value)", "[array]") {
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array by sequence - zero case (template with ::value)",
+          "[array]") {
+    auto arr = stdx::make_array<V>(std::make_integer_sequence<int, 0>{});
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 TEST_CASE("make_array by extent (template with ::value)", "[array]") {
     auto arr = stdx::make_array<V, 5>();
     STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array by extent - zero case (template with ::value)",
+          "[array]") {
+    auto arr = stdx::make_array<V, 0>();
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 namespace {
 struct {
     template <auto I> auto operator()() { return I + 1; }
@@ -38,8 +60,20 @@ TEST_CASE("make_array by sequence (factory function template)", "[array]") {
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
 
+TEST_CASE("make_array by sequence - zero case (factory function template)",
+          "[array]") {
+    auto arr = stdx::make_array(std::make_integer_sequence<int, 0>{}, f);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}
+
 TEST_CASE("make_array by extent (factory function template)", "[array]") {
     auto arr = stdx::make_array<5>(f);
     STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 5>>);
     CHECK(arr == std::array{1, 2, 3, 4, 5});
 }
+
+TEST_CASE("make_array by extent - zero case (factory function template)",
+          "[array]") {
+    auto arr = stdx::make_array<0>(f);
+    STATIC_CHECK(std::is_same_v<decltype(arr), std::array<int, 0>>);
+}