Cumulative Product of Template Parameter Pack

judge Published at Dev

Judge

I'm trying to initialise a static and constant array with the cumulative product of a template parameter pack:

template <int ...D>
class Foo
{
     static const std::array<const Size, sizeof...(D)> _array;
};
template <int...D> const std::array<const int, sizeof...(D)> Foo<D...>::_array = 
{ cumulative_product<D...>() };

How do I write the function cumulative_product<>(), such that it transforms D... into the cumulative product of D...? E.g.

Foo<1,2,3,4>::_array;// = {1,1*2,1*2*3,1*2*3*4} = {1,2,6,24}.

Solution: Massive thank you to @bogdan for your excellent C++14 solution, and improvements to my C++11 solution.

#include <array>
#include <iostream>

#define CPP_VERSION 11

#if CPP_VERSION >= 14

// Credit: @bogdan at http://stackoverflow.com/q/37373602/6367128
template<int... Args> constexpr std::array<int, sizeof...(Args)> cumulative_product(int seed = 1) { return{ { seed *= Args ... } }; }

#elif CPP_VERSION == 11

// Acknowledgement: Huge thank you to @bogdan for making the code more portable, concise and readable!
namespace details
{
   template<int N, int i, int j, int ...Args> struct c_product_gen               // N counts down to zero
   {
      static constexpr std::array<int, sizeof...(Args)+1> get() { return c_product_gen<N - 1, i*j, Args..., i*j>::get(); }
   };
   template<int i, int j, int ...Args> struct c_product_gen<0, i, j, Args...>    // The end point of the template recursion
   {
      static constexpr std::array<int, sizeof...(Args)+1> get() { return { { j, Args... } }; }
   };
}

template<int... Args> constexpr std::array<int, sizeof...(Args)> cumulative_product() { return details::c_product_gen<sizeof...(Args), 1, Args...>::get(); }

#else // CPP_VERSION < 11

template<int... Args> constexpr std::array<int, sizeof...(Args)> cumulative_product() 
{ 
    static_assert(false, "C++ version 11 or greater is required.");
    return std::array<int, sizeof...(Args)>();
}

#endif

int main()
{
   constexpr auto a = cumulative_product<1,2,3,4,5>();
   for(auto i : a) std::cout << i << ' ';    // Output: 1 2 6 24 120 
   std::cout << '\n';  
}

Piotr Skotnicki

#include <array>
#include <utility>
#include <cstddef>

template <int... D, std::size_t... Is>
constexpr std::array<int, sizeof...(D)> cumulative_product(std::index_sequence<Is...>)
{
    static_assert(sizeof...(D), "Missing initializers");
    int a[]{ D... };
    for (int i = 1; i < int(sizeof...(D)); ++i)
    {
        a[i] *= a[i-1];
    }
    return {{ a[Is]... }};
}

template <int... D>
constexpr auto cumulative_product()
{
    return cumulative_product<D...>(std::make_index_sequence<sizeof...(D)>{});
}

template <int... D>
struct Foo
{
     static constexpr std::array<int, sizeof...(D)> _array  = cumulative_product<D...>();
};

DEMO

Collected from the Internet

Please contact [email protected] to delete if infringement.