Re: How to fill in a compile-time (but not text-time) fixed-sized
array.
On 2013-08-05 03:44, Daryle Walker wrote:
If the size of an array is fixed in the source text, it's easy to
define it:
struct test1
{
static constexpr
int my_data[] = { 1, 2, 3, 4 };
};
constexpr
int test1::my_data[ 4 ];
But what if the array's size is determined by an algorithm, still fixed
in compile-time. Can it be written?
Yes.
template < int X >
struct my_meta_func
: std::integeral_constant<int, Whatever>
{ };
template < std::size_t L >
struct test2
{
static constexpr
int my_data[] = { my_meta_func<0>::value,
my_meta_func<1>::value, ..., my_meta_func<L-1>::value };
// How do I actually fill in the above line?
};
template < std::size_t L >
int test2<L>::my_data[ L ];
I (mostly) have no clue how to do this. Right before writing this, I
came up with the C++11 trick of appending (C++) varargs to a variadic
(function) template, then using that list to initialize an array when
it's long enough. Will that work?
I have not fully grasped your suggestion here (Especially it is unclear
to me what you mean by 'list' in this context), but given the following
tools
template<std::size_t... N>
struct index_sequence
{
static constexpr std::size_t size() { return sizeof...(N); }
};
template<std::size_t I, class IndexTuple, std::size_t N>
struct make_index_sequence_impl;
template<std::size_t I, std::size_t... Indices, std::size_t N>
struct make_index_sequence_impl<I, index_sequence<Indices...>, N>
{
typedef typename make_index_sequence_impl<I + 1,
index_sequence<Indices..., I>, N>::type type;
};
template<std::size_t N, std::size_t... Indices>
struct make_index_sequence_impl<N, index_sequence<Indices...>, N>
{
typedef index_sequence<Indices...> type;
};
template<std::size_t N>
using make_index_sequence = typename make_index_sequence_impl<0,
index_sequence<>, N>::type;
this is not too hard to implement, e.g. you could write:
template<class Tuple>
struct test2_base;
template<std::size_t... I>
struct test2_base<index_sequence<I...>>
{
static constexpr int my_data[] = { my_meta_func<I>::value... };
};
template<std::size_t... I>
constexpr int
test2_base<index_sequence<I...>>::my_data[index_sequence<I...>::size()];
template<std::size_t L>
struct test2 : test2_base<make_index_sequence<L>>
{
};
Note that for C++14, the templates index_sequence and
make_index_sequence are already provided by the Standard Library in
namespace std.
Can a multi-dimensional array be
filled with initialization of a flat list? (That works in non-meta
contexts.)
Sure, why not?
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]