Sortowanie malejące po przekątnej.

Muszę posortować elementy na przekątnej w tablicy A.
Jak posortować to malejąco ?

void sortowanie(double t[][8]) 
{
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            if (i == j)
            {                       
                    std::cout << t[i][j] << " ";          
            }
        } 
    }
}

Teraz tylko wyświetla przekątną.

A możesz zapisac elementy przekątnej do wektora i go posortować?

@stefano_cx: Tworzysz wektor (tablice, albo jakiś kontener np. vector), przechodzisz w pętli po tablicy A i wpisujesz do tego wektora wartości z przekątnej, sortujesz wektor. Done

@Dregorio: zrobiłem coś takiego, ale dalej nie sortuje....

void sortowanie(double t[][8])
{
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            if (i == j)
            {
                std::vector<double> w; 
                w.push_back(t[i][j]);

                std::sort(w.begin(), w.end(), std::greater<double>());  

                for (int a = 0; a < w.size(); a++)
                {
                    std::cout << w[a] << " ";
                }

            }
        }
    }
}

@stefano_cx: To napisz mi najlepiej w punktach, co robisz w tym programie, linijka za linijka

Jest to tragiczne nieco, ale gdybyś dał deklarację wektora w w pierwszej linijce funkcji, to już by "zadziałało".
Możesz też usunąć nadmierne pętle, oraz wyciągnąć z nich to co powinno być wyciągnięte.

void sortowanie(double t[][8])
{
    std::vector<double> w; 
    for (int i = 0; i < 8; i++)
    {
        w.push_back(t[i][i]);
    }

    std::sort(w.begin(), w.end(), std::greater<double>());  

    for (int a = 0; a < w.size(); a++)
    {
        std::cout << w[a] << " ";
    }
}

teraz już też powinno "działać", ale już nieco trochę lepiej. Nadal nie wstawiasz elementów z powrotem do wejściowej tablicy.

Alternatywne rozwiązanie, bez tworzenia nowego wektora:

template<typename T, size_t N>
struct H {
    T data[N+1];
    H(const H<T, N>& other) {
        *this = other;
    }
    H<T, N>& operator=(const H<T, N>& other) {
        data[0] = other.data[0];
        return *this;
    }
};

template<typename T, size_t N>
struct std::greater<H<T, N>> {
    constexpr bool operator()(const H<T, N>& h1, const H<T, N>& h2) {
        return h1.data[0] > h2.data[0];
    }
};


void sortowanie(double t[][8]) {
    H<double, 8> *p = reinterpret_cast<H<double, 8>*>(t);
    std::sort(p, p + 8, std::greater<H<double, 8>>());
}

Problem został rozwiązany.
Podaję kod dla wszystkich, którym może przydać się rozwiązanie problemu.

void sortowanie(double t[][8])
{
    std::vector<double> w;

    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 8; j++)
        {

            if (i == j)
            {
                w.push_back(t[i][j]);
            }

        }
    }

    std::sort(w.rbegin(), w.rend());

    for (int a = 0; a < w.size(); a++)
    {
        std::cout << w[a] << " ";
    }
}