Могу ли я инициализировать массив, используя std::initializer_list вместо инициализатора, заключенного в фигурные скобки?

Другой правильно ответил, что это невозможно заранее. Но с маленькими помощниками вы можете подобраться довольно близко

template<typename T, std::size_T N, std::size_t ...Ns>
std::array<T, N> make_array_impl(
    std::initializer_list<T> t,
    std::index_sequence<Ns...>) 
{
    return std::array<T, N>{ *(t.begin() + Ns) ... };
}

template<typename T, std::size_t N>
std::array<T, N> make_array(std::initializer_list<T> t) {
    if(N > t.size())
       throw std::out_of_range("that's crazy!");
    return make_array_impl<T, N>(t, std::make_index_sequence<N>());
}

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

template<typename T, std::size_t N>
struct ArrayInitializer {
    template<typename U> struct id { using type = U; };
    std::array<T, N> t;

    template<typename U = std::initializer_list<T>>
    ArrayInitializer(typename id<U>::type z) 
        :ArrayInitializer(z, std::make_index_sequence<N>())
    { 
        if(N > z.size())
            throw std::out_of_range("that's crazy!");
    }

    template<typename ...U>
    ArrayInitializer(U &&... u)
       :t{ std::forward<U>(u)... }
    { }

private:
    template<std::size_t ...Ns>
    ArrayInitializer(std::initializer_list<T>& t,
                     std::index_sequence<Ns...>)
       :t{ *(t.begin() + Ns) ... }
    { }
};

template<typename T, std::size_t N>
std::array<T, N> f(ArrayInitializer<T, N> ai) {
    return std::move(ai.t);
}

int main() {
   f<int, 5>({1, 2, 3, 4, 5});  // OK 
   f<int, 5>({1, 2, 3, 4, 5, 6});  // "too many initializers for array<int, 5>"

   std::initializer_list<int> il{1, 2, 3, 4, 5};
   f<int, 5>(il); // ok
}

Обратите внимание, что как нестатический случай в верхней части ответа, так и случай «head-desk» проверяют только то, предоставляете ли вы слишком мало инициализирующих элементов, а затем выдаете ошибки для случая initializer_list. Если вы укажете слишком много для случая initializer_list, конечные элементы просто будут проигнорированы.

Насколько я знаю, нет: вы не можете инициализировать std::array с помощью std::initializer_list.

Проблема в том, что std::array задуман как облегченная замена (оболочка) классического массива в стиле C. Настолько легкий, что без конструкторов, поэтому можно использовать только неявный конструктор.

Возможна конструкция с агрегатной инициализацией (через неявный конструктор), потому что это возможно для массива в стиле C.

Но std::initializer_list — это класс, более сложный, чем агрегатная инициализация.

Например, вы можете инициализировать std::vector с помощью std::initializer_list, но только потому, что для std::vector существует явный конструктор, который получает std::initializer_list. Но std::vector - более тяжелый класс.

Единственное решение, которое я вижу, - это двухэтапный путь: (1) построение и (2) копирование значений std::initializer_list. Что-то типа

std::array<int, 3> arr5;

auto  ui = 0U;
auto  cit = il.cbegin();

while ( (ui < arr5.size()) && (cit != il.cend()) )
   arr5[ui++] = *cit++;

p.s.: извините за мой плохой английский.

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

Следовательно, возможны только совокупная инициализация или тривиальное копирование. std::initializer_list — это класс, отличный от std::array, поэтому требуется (отсутствующее) неявное преобразование.

См. http://en.cppreference.com/w/cpp/language/aggregate_initialization и http://en.cppreference.com/w/cpp/container/array для справки.