Isso é um pouco mais de um enigma do que um problema do mundo real, mas eu me envolvi em uma situação onde eu quero ser capaz de escrever algo que se comporta exatamente como

template<int N>
struct SortMyElements {
    int data[N];

    template<typename... TT>
    SortMyElements(TT... tt) : data{ tt... }
    {
        std::sort(data, data+N);
    }
};

int main() {
    SortMyElements<5> se(1,4,2,5,3);
    int se_reference[5] = {1,2,3,4,5};
    assert(memcmp(se.data, se_reference, sizeof se.data) == 0);
}

exceto que eu quero oSortMyElements construtor a serconstexpr.

Obviamente, isso é possível para fixoN; por exemplo, eu posso me especializar

template<>
struct SortMyElements<1> {
    int data[1];
    constexpr SortMyElements(int x) : data{ x } {}
};


template<>
struct SortMyElements<2> {
    int data[2];
    constexpr SortMyElements(int x, int y) : data{ x>y?y:x, x>y?x:y } {}
};

Mas como eu generalizo isso em algo que vai funcionar paraqualquer N?

Por favor, note que os elementos da matriz têm que vir dos valores reais dos argumentos, não dos argumentos de tipo não-modelo; meus elementos vêm deconstexpr expressões que, apesar de serem avaliadas em tempo de compilação, residem firmemente dentro do "sistema de valores", ao invés do "sistema de tipos". (Por exemplo,Boost.MPL'ssort funciona estritamente dentro do "sistema de tipos".

Eu postei uma "resposta" de trabalho, mas é muito ineficiente para trabalharN > 6. Eu gostaria de usar isso com2 < N < 50 ou por aí.

(PS - Na verdade, o que eu realmente gostaria de fazer é embaralhar todos os zeros em uma matriz até o final da matriz e compactar os valores diferentes de zero na frente, o que pode ser mais fácil do que a classificação completa; mais fácil de descrever.Sinta-se à vontade para resolver o problema de "embaralhar zeros" em vez de ordenar.