模板元编程：编译期直接选择排序

#include <iostream>

/******** list ****************************************************************/

template <typename T, T... xs>
struct List
{
};

/******** print ***************************************************************/

template <typename T, T x0, T... xs>
void print(List<T, x0, xs...>)
{
    std::cout << x0 << ' ';
    print(List<T, xs...>{});
}

template <typename T>
void print(List<T>)
{
    std::cout << std::endl;
}

/******** concat **************************************************************/

template <typename T, class L1, class L2>
struct Concat;

template <typename T, T... xs1, T... xs2>
struct Concat<T, List<T, xs1...>, List<T, xs2...>>
{
    using val = List<T, xs1..., xs2...>;
};

/******** conditional expression **********************************************/

template <typename T, bool predicate, T consequence, T alternative>
struct Conditional;

template <typename T, T consequence, T alternative>
struct Conditional<T, true, consequence, alternative>
{
    static const T val = consequence;
};

template <typename T, T consequence, T alternative>
struct Conditional<T, false, consequence, alternative>
{
    static const T val = alternative;
};

/******** pop_min *************************************************************/

template <typename T, class L>
struct PopMin;

template <typename T, T x0, T x1>
struct PopMin<T, List<T, x0, x1>>
{
    using remains = List<T, Conditional<T, (x0 < x1), x1, x0>::val>;
    static const T min = Conditional<T, (x0 < x1), x0, x1>::val;
};

template <typename T, T x0, T... xs>
struct PopMin<T, List<T, x0, xs...>>
{
    using _tail = PopMin<T, List<T, xs...>>;
    using remains = typename Concat<
        T,
        List<T, Conditional<T, (x0 < _tail::min), _tail::min, x0>::val>,
        typename _tail::remains>::val;
    static const T min = Conditional<T, (x0 < _tail::min), x0, _tail::min>::val;
};

/******** Sorted **************************************************************/

template <typename T, class L>
struct Sorted;

template <typename T, T x0, T x1>
struct Sorted<T, List<T, x0, x1>>
{
    using result = List<
        T,
        Conditional<T, (x0 < x1), x0, x1>::val,
        Conditional<T, (x0 < x1), x1, x0>::val>;
};

template <typename T, T x0, T... xs>
struct Sorted<T, List<T, x0, xs...>>
{
    using _tail = PopMin<T, List<T, xs...>>;

    using _remains = typename Sorted<
        T,
        typename Concat<
            T,
            List<T, Conditional<T, (x0 < _tail::min), _tail::min, x0>::val>,
            typename _tail::remains>::val>::result;

    using result = typename Concat<
        T,
        List<T, Conditional<T, (x0 < _tail::min), x0, _tail::min>::val>,
        _remains>::val;
};

/******** main ****************************************************************/

int main(int argc, char const *argv[])
{
    using list = List<int, 7, 45, 2, 2, 4, 6, 3, 12, 4>;
    using sorted = Sorted<int, list>;

    print(sorted::result{});

    return 0;
}