Передача аргументов конструктору контейнера, похожему на массив

Если я правильно понимаю вашу проблему, я также наткнулся на полную негибкость std::array в отношении построения элементов в пользу агрегатной инициализации (и отсутствие статически распределенного контейнера с гибкими параметрами построения элементов). Лучший подход, который я придумал, заключался в создании пользовательского контейнера, похожего на массив, который принимает итератор для создания своих элементов. Это полностью гибкое решение:

• Работает как с контейнерами фиксированного размера, так и с контейнерами динамического размера.
• Может передавать разные или одинаковые параметры конструкторам элементов
• Может вызывать конструкторы с одним или несколькими (кортежное кусочное построение) аргументами или даже разными конструкторами для разных элементов (с инверсией управления)

Для вашего примера это будет так:

const size_t SIZE = 10;

std::array<int, SIZE> params;
for (size_t c = 0; c < SIZE; c++) {
    params[c] = c;
}

Array<Foo, SIZE> foos(iterator_construct, &params[0]); //iterator_construct is a special tag to call specific constructor
// also, we are able to pass a pointer as iterator, since it has both increment and dereference operators

Примечание: вы можете полностью пропустить выделение массива параметров здесь, используя пользовательский класс итератора, который вычисляет его значение из его позиции на лету.

Для конструктора с несколькими аргументами это будет:

const size_t SIZE = 10;

std::array<std::tuple<int, float>, SIZE> params; // will call Foo(int, float)
for (size_t c = 0; c < SIZE; c++) {
    params[c] = std::make_tuple(c, 1.0f);
}

Array<Foo, SIZE> foos(iterator_construct, piecewise_construct, &params[0]);

Конкретный пример реализации представляет собой довольно большой фрагмент кода, поэтому, пожалуйста, дайте мне знать, если вам нужно больше информации о деталях реализации помимо общей идеи - тогда я обновлю свой ответ.

Я бы использовал заводскую лямбду.

Лямбда принимает указатель на место построения и индекс и отвечает за построение.

Это также упрощает копирование/перемещение, что является хорошим знаком.

template<class T, std::size_t N>
struct my_array {
  T* data() { return (T*)&buffer; }
  T const* data() const { return (T const*)&buffer; }

  // basic random-access container operations:
  T* begin() { return data(); }
  T const* begin() const { return data(); }
  T* end() { return data()+N; }
  T const* end() const { return data()+N; }
  T& operator[](std::size_t i){ return *(begin()+i); }
  T const& operator[](std::size_t i)const{ return *(begin()+i); }

  // useful utility:
  bool empty() const { return N!=0; }
  T& front() { return *begin(); }
  T const& front() const { return *begin(); }
  T& back() { return *(end()-1); }
  T const& back() const { return *(end()-1); }
  std::size_t size() const { return N; }

  // construct from function object:
  template<class Factory,
    typename std::enable_if<!std::is_same<std::decay_t<Factory>, my_array>::value, int> =0
  >
  my_array( Factory&& factory ) {
    std::size_t i = 0;
    try {
      for(; i < N; ++i) {
        factory( (void*)(data()+i), i );
      }
    } catch(...) {
      // throw during construction.  Unroll creation, and rethrow:
      for(std::size_t j = 0; j < i; ++j) {
        (data()+i-j-1)->~T();
      }
      throw;
    }
  }
  // other constructors, in terms of above naturally:
  my_array():
    my_array( [](void* ptr, std::size_t) {
      new(ptr) T();
    } )
  {}
  my_array(my_array&& o):
    my_array( [&](void* ptr, std::size_t i) {
      new(ptr) T( std::move(o[i]) );
    } )
  {}
  my_array(my_array const& o):
    my_array( [&](void* ptr, std::size_t i) {
      new(ptr) T( o[i] );
    } )
  {}
  my_array& operator=(my_array&& o) {
    for (std::size_t i = 0; i < N; ++i)
      (*this)[i] = std::move(o[i]);
    return *this;
  }
  my_array& operator=(my_array const& o) {
    for (std::size_t i = 0; i < N; ++i)
      (*this)[i] = o[i];
    return *this;
  }
private:
  using storage = typename std::aligned_storage< sizeof(T)*N, alignof(T) >::type;
  storage buffer;
};

он определяет my_array(), но компилируется, только если вы пытаетесь его скомпилировать.

Поддержка списка инициализаторов относительно проста. Трудно решить, что делать, когда il недостаточно длинный или слишком длинный. Я думаю, вы можете захотеть:

template<class Fail>
my_array( std::initializer_list<T> il, Fail&& fail ):
  my_array( [&](void* ptr, std::size_t i) {
    if (i < il.size()) new(ptr) T(il[i]);
    else fail(ptr, i);
  } )
{}

который требует, чтобы вы передали «что делать при сбое». Мы могли бы по умолчанию использовать throw, добавив:

template<class WhatToThrow>
struct throw_when_called {
  template<class...Args>
  void operator()(Args&&...)const {
    throw WhatToThrow{"when called"};
  }
};

struct list_too_short:std::length_error {
  list_too_short():std::length_error("list too short") {}
};
template<class Fail=ThrowWhenCalled<list_too_short>>
my_array( std::initializer_list<T> il, Fail&& fail={} ):
  my_array( [&](void* ptr, std::size_t i) {
    if (i < il.size()) new(ptr) T(il[i]);
    else fail(ptr, i);
  } )
{}

что, если я написал это правильно, приводит к тому, что слишком короткий список инициализаторов вызывает осмысленное сообщение о выбросе. На вашей платформе вы можете просто exit(-1), если у вас нет исключений.