Отсортировать по убыванию элементов последнего столбца целочисленный двухмерный массив

#ifndef MATRIX_HPP
#define MATRIX_HPP
 
#include <exception>
#include <iostream>
#include <random>
#include <vector>
 
enum Order { desc, inc };
 
class Matrix {
 
    public:
        Matrix();
        Matrix(std::size_t, std::size_t);
        Matrix(std::size_t, std::size_t, int);
        Matrix(const Matrix&);
        ~Matrix();
 
        void fillRandomValue(int, int);
 
        void sortRowsByCol(std::size_t, Order = inc);
 
        void print();
 
        bool isEmpty() const;
 
    private:
        void swap(std::vector<int>&, std::vector<int>&);
        std::size_t rows;
        std::size_t cols;
        std::vector<std::vector<int>> matrix;
 
};
 
#endif //MATRIX_HPP

#include "Matrix.hpp"
 
//----------------------------------------------------------------------------------------
Matrix::Matrix()
    : rows(0), cols(0), matrix() {
 
    //TODO
 
}
//----------------------------------------------------------------------------------------
Matrix::Matrix(std::size_t r, std::size_t c)
    : rows(r), cols(c) {
 
    matrix.resize(rows);
 
    for (auto& rows : matrix) {
 
        rows.resize(cols);
 
    }
 
}
//----------------------------------------------------------------------------------------
Matrix::Matrix(std::size_t r, std::size_t c, int v)
    : Matrix(r, c) {
 
    for (auto& row : matrix) {
 
        for (auto& value : row) {
 
            value = v;
 
        }
 
    }
 
}
//----------------------------------------------------------------------------------------
Matrix::Matrix(const Matrix& m) {
 
    matrix = m.matrix;
    rows = m.rows;
    cols = m.cols;
 
}
//----------------------------------------------------------------------------------------
Matrix::~Matrix() {
 
    //TODO
 
}
//----------------------------------------------------------------------------------------
void Matrix::fillRandomValue(int lowerBound, int upperBound) {
 
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(lowerBound, upperBound);
 
    for (auto& row : matrix) {
 
        for (auto& value : row) {
 
            value = dist(gen);
 
        }
 
    }
 
}
//----------------------------------------------------------------------------------------
void Matrix::sortRowsByCol(std::size_t col, Order order) {
 
    if (order == Order::inc) {
 
        for (std::size_t i { 0 }; i < rows; ++i) {
            
            for (std::size_t j { i }; j < rows; ++j) {
            
                if (matrix.at(i).at(col) > matrix.at(j).at(col)) {
            
                    swap(matrix.at(i), matrix.at(j));
            
                }
            
            }
            
        }
 
    } else {
 
        for (std::size_t i { 0 }; i < rows; ++i) {
            
            for (std::size_t j { i }; j < rows; ++j) {
            
                if (matrix.at(i).at(col) < matrix.at(j).at(col)) {
            
                    swap(matrix.at(i), matrix.at(j));
            
                }
            
            }
            
        }
 
    }
 
}
//----------------------------------------------------------------------------------------
void Matrix::print() {
 
    for (auto row : matrix) {
 
        for (auto value : row) {
 
            std::cout
                << value << " ";
 
        }
 
        std::cout
            << std::endl;
 
    }
 
}
//-----------------------------------------------------------------------------------------
bool Matrix::isEmpty() const {
 
    return matrix.size();
 
}
//-----------------------------------------------------------------------------------------
void Matrix::swap(std::vector<int>& lhs, std::vector<int>& rhs) {
 
    std::size_t size = lhs.size();
 
    if (lhs.size() != rhs.size()) {
 
        std::runtime_error("Matrix::swap(): The size of vectors are different");
 
    }
 
    int temp;
 
    for (std::size_t i { 0 }; i < size; ++i) {
 
        temp = lhs.at(i);
        lhs.at(i) = rhs.at(i);
        rhs.at(i) = temp;
 
    }
 
}