compile time sort

make_sort_array.cpp

 #include <cstddef>

template<typename T1, typename T2>
struct StaticPair {
    T1 first;
    T2 second;
    friend constexpr bool operator<(const StaticPair& lhs, const StaticPair& rhs) noexcept {
        return lhs.first < rhs.first;
    }
    
    friend constexpr bool operator>(const StaticPair& lhs, const StaticPair& rhs) noexcept {
        return lhs.first > rhs.first;
    }
};

template <typename T, size_t N>
struct array
{
    using size_type = size_t;

    constexpr T& operator[](size_t i)
    {
        return arr[i];
    }

    constexpr const T& operator[](size_t i) const
    {
        return arr[i];
    }

    constexpr size_t size() const
    {
        return N;
    }

    constexpr const T* begin() const
    {
        return arr;
    }

    constexpr const T* end() const
    {
        return arr + N;
    }
    
    constexpr const T& front() const
    {
        return arr[0];
    }
    constexpr const T& back() const
    {
        return arr[N-1];
    }

    T arr[N];
};

template<typename Array>
constexpr void comb_sort ( Array & array_ ) noexcept {
}

template<typename T, size_t N>
constexpr auto makeArrayPairs(const T (&arr)[N]) noexcept {
    array<T,N> a{};
    for(size_t i = 0; i<N; ++i)  a[i] = arr[i];
    auto gap = a.size();
    bool swapped = false;
    while ( ( gap > 1ul ) || swapped ) {
        if ( gap > 1ul ) {
            gap = gap / 1.247330950103979;
        }
        swapped = false;
        for ( size_t i = 0; gap + i < a.size(); ++i ) {
            if ( a[ i ] > a[ i + gap ] ) {
                auto swap = a[ i ];
                a[ i ] = a[ i + gap ];
                a[ i + gap ] = swap;
                swapped = true;
            }
        }
    }
    return a;
}

int main() {
    const auto a = makeArrayPairs<StaticPair<int,int>>({{3,10}, {9,20}, {1,30}});
    return a.back().second;
}