Как я могу использовать `std::array` для параметра шаблона вида `template‹typename› class`?

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

template<typename T, typename TupleMfn>
class tree
{
private:
    using Tuple = TupleMfn::template apply<tree>;

    T m_value;
    Tuple m_children;
};

с:

template <size_t N>
struct array_builder {
    template <class T>
    using apply = std::array<T, N>;
};

template <typename T, size_t N>
using static_tree = tree<T, array_builder<N>>;

Это упростит использование и с другими типами контейнеров, поскольку мы можем создать оболочку для шаблонов шаблонов, которая возвращает нам метафункцию:

template <template <typename...> class X>
struct as_metafunction {
    template <class... Args>
    using apply = X<Args...>;
}; 

template <typename T>
using vector_tree = tree<T, as_metafunction<std::vector>>;

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

template <class T, class N>
struct meta_array : std::array<T, N::value> // obviously I am terrible at naming things
{ };

template <size_t N>
using size_t_ = std::integral_constant<size_t, N>;

А затем укажите аргументы-заполнители для применения tree:

template <class T, size_t N>
using static_tree = tree<T, meta_array<_, size_t_<N>>>;

template <class T>
using vector_tree = tree<T, std::vector<_>>;

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

Один из способов сделать это — использовать ваш вспомогательный класс, но изменить класс на

template<typename T, template<typename> class Tuple>
class tree
{
    // Indirection (I'm omitting the question of whether these should be
    //     smart pointers.
    Tuple<tree<T, Tuple> *> m_children;
};

Другой способ сделать Tuple обычным параметром шаблона:

#include <array>
#include <type_traits>

template<typename T, class Tuple>
class tree                                                                                                                                  
{
private:
    static_assert(
        std::is_same<void *, typename Tuple::value_type>::value, 
        "Tuple must be a container of void *");

private:
    T m_value;
    Tuple m_children;
};

template<typename T, std::size_t N>
using static_tree = tree<T, std::array<void *, N>>;

int main()
{
    static_tree<int, 8> t;
}

С одной стороны, вспомогательный класс был исключен. OTOH, Tuple является контейнером void *: создатели экземпляров знают об этом, и класс внутри должен выполнять приведения типов. Это компромисс. Я бы придерживался вашей первоначальной версии (с предложенными изменениями, конечно).

Класс X не может содержать несколько копий фактических экземпляров класса X, кроме как логически.

А если у нас есть

struct X {
  std::array<X, 2> data;
};

единственный возможный размер для X — бесконечность, так как sizeof(X) = 2*sizeof(X), а все типы в C++ имеют sizeof(X)>=1.

C++ не поддерживает бесконечно большие типы.

Ваша вторая проблема заключается в том, что экземпляры типов не являются шаблонами.

template<typename T, template<typename> class Tuple>
class tree

это принимает тип T и template Tuple. Второй аргумент не является типом.

template<typename T, std::size_t N>
using static_tree = tree<T, std::array<T, N>>;

здесь ваш второй аргумент является типом, а не шаблоном.

template<std::size_t N>
struct array_of_size {
  template<class T>
  using result=std::array<T,N>;
};
template<typename T, std::size_t N>
using static_tree = tree<T, array_of_size<N>::template result>;

решит вашу проблему, кроме вышеупомянутой «проблемы бесконечного размера». Здесь мы передаем шаблон array_of_size<N>::result в tree.

Чтобы решить проблему бесконечного размера, вы должны хранить указатели (или что-то подобное) в массиве. Итак, мы получаем:

template<std::size_t N>
struct array_of_ups_of_size {
  template<class T>
  using result=std::array<std::unique_ptr<T>,N>;
};
template<typename T, std::size_t N>
using static_tree = tree<T, array_of_ups_of_size<N>::template result>;

и теперь у вашего static_tree есть N дочерних элементов, каждый из которых является unique_ptr похожим static_tree.

Это все еще не работает из-за проблем с деструктором.

template<typename T, template<typename> class Tuple>
class tree
{
private:
  T m_value;
  Tuple<tree> m_children;
public:
  ~tree();
};

template<typename T, template<typename> class Tuple>
tree<T,Tuple>::~tree() = default;

Я думаю, вышеизложенное исправляет это, как это ни странно.

По сути, когда вы создаете массив дочерних элементов, тип дерева неполный. При уничтожении вызывается удаление. В этот момент дерево должно быть завершено. Откладывая dtor, мы надеемся решить проблему.

Я не уверен, требуется ли этот метод для шаблонов, но он подходит для классов, не являющихся шаблонами.

Или вы можете реализовать привязку параметра шаблона, как вы предложили (немного более общий, чем ваш helper):

template<std::size_t N, template<typename,std::size_t> class T>
struct bind2nd
{
    template<typename F>
    using type = T<F,N>;
};

template<std::size_t N, typename T>
using static_tree = tree<T, bind2nd<N,std::array>::template type>;