Best Way to Create N Objects at Compile Time

Question

I wondered how you would go about creating N objects at compile time with templates. Or this was indeed even good practise.

I have a header file containing some constants:

constexpr size_t N_TIMES = 3;
constexpr uint32_t MIN[N_TIMES] = {0,1,2};
constexpr uint32_t MAX[N_TIMES] = {1,2,3};

Then a header file containing a template which will be generate "N" times:

template <typename T>
class foo
{

public:

  foo(uint32_t min , uint32_t max) :
    min(min),
    max(max)
  {
    std::cout << "I was created with " << min << " " << max << std::endl;
  }

private:

  const uint32_t min;
  const uint32_t max;
};

The part I'm a little unsure about is I have:

template <typename T>

class bar 
{
public:

  bar()
  {

    for(auto i = 0; i < N_TIMES; i ++)
          {
            foo_[i] = foo<T>(MIN[i], MAX[i]);
          }
  }
private:
  std::array<foo<T>, N_TIMES> foo_;
};

I currently get the error:

cannot be assigned because its copy assignment operator is implicitly deleted

But since it's in the constructor, it'll generate this after compiling anyway. So really I was just wondering how I should be going about this instead. If there was some kind of clever recursive trick I could pull to create these objects for me at compile time.

You could use the indexes trick and forwarding ctors: would let you construct thr foo array directly, no loop or assignment. — Yakk - Adam Nevraumont, Mar 17 '16 at 13:35

score 1 · Accepted Answer · answered Mar 17 '16 at 13:34

1

You may use std::index_sequence:

namespace detail
{

    template <typename T, std::size_t N, std::size_t...Is>
    std::array<Foo<T>, N> make_foo_array(std::index_sequence<Is...>)
    {
        return {{Foo<T>(MIN[Is], MAX[Is])...}};    
    }

}

template <typename T, std::size_t N>
std::array<Foo<T>, N> make_foo_array()
{
    return detail::make_foo_array<T, N>(std::make_index_sequence<N>{});
}

And then

template <typename T>
class bar 
{
public:
    bar() : foo_(make_foo_array<T, N_TIMES>()) {}
private:
    std::array<foo<T>, N_TIMES> foo_;
};

answered Mar 17 '16 at 13:34

Jarod42

203,559
14
181
302

@fiz: `index_sequence` and `make_index_sequence` can be made in c++11, (but indeed was introduced in c++14). – Jarod42 Mar 21 '16 at 19:50
http://stackoverflow.com/questions/27124920/compile-time-generate-integer-sequence-with-one-left-out solution here – fiz Mar 21 '16 at 20:47

Best Way to Create N Objects at Compile Time

1 Answers1