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

int main ()
{
const unsigned int str = 10, col = 10;
    int a[str][col];
 
    for (int i = 0; i < str; i++) {
        for (int j = 0; j < col; j++) {
            a[i][j] = rand() % 4 + 0;
        }
    }
 
    int* b[10];
    int c[10];
 
    for (int i = 0; i < 10; i++)
    {
        int sum = 0;
        for (int j = 0; j < 10; j++)
            sum += a[i][j];
        c[i] = sum;
    }
 
    for (int i = 0; i < 10; i++)
        b[i] = a[i];
 
    for (int i = 0; i < 9; i++)
        for (int j = i + 1; j < 10; j++)
            if (c[i] < c[j])
            {
                swap(c[i], c[j]);
                swap(b[i], b[j]);
            }
 
    for (int i = 0; i < str; i++) {
        for (int j = 0; j < col; j++) {
            cout << setw(4) << a[i][j];
        }
        cout << endl;
    }
 
    system("pause");
    return 0;
}

b[i] = i;

    for (int i = 0; i < str; i++) {
        for (int j = 0; j < col; j++) {
            cout << setw(4) << a[b[i]][j];
        }
        cout << endl;
    }

#include <iostream>
#include <ctime>
 
int rrand(int range_max)
{   return rand() % (range_max + 1);
}
 
int main()
{   srand((unsigned int)time(NULL));
 
    const int ROW    = 10;
    const int COLUMN = 11; /// В 11 столбе будем хранить сумму элементов строки.
 
    ///-----------------------------------|
    /// Выделение памяти под таблицу.     |
    ///-----------------------------------:
    int** tab;
    tab = new int*[ROW];
    for(int i = 0; i < ROW; ++i)
    {   tab[i] = new int[COLUMN];
    }
 
    ///-----------------------------------|
    /// Рандомная иницилизация.           |
    ///-----------------------------------:
    for(int i = 0; i < ROW; ++i)
    {   tab[i][COLUMN - 1] = 0;
        for(int j = 0; j < COLUMN - 1; ++j)
        {
            int r = rrand(2);
            switch(r)
            {   case 0: r = 0; break;
                case 1: r = 1; break;
                case 2: r = 3; break;
            }
            tab[i][j] = r;
            tab[i][COLUMN - 1] += r;
        }
    }
 
    ///-----------------------------------|
    /// Сортируем(пузырьком).             |
    ///-----------------------------------:
    int tmp = 0;
    for(int i = 0; i < ROW; i++)
    {   for(int j = (ROW - 1); j >= (i+1); j--)
        {   if(tab[j][COLUMN - 1] > tab[j - 1][COLUMN - 1])
            {   std::swap(tab[j], tab[j-1]);
            }
        }
    }
 
    ///-----------------------------------|
    /// Выводим на экран.                 |
    ///-----------------------------------:
    std::cout << "  | ";
    for(int j = 0; j < COLUMN-1; ++j)
    {   std::cout << j << "  ";
    }
    std::cout << "Sum\n";
    for(int j = 0; j < 12; ++j)
    {   std::cout << "---";
    }
    std::cout << "\n";
    for(int i = 0; i < ROW; ++i)
    {   std::cout << i << " | ";
        for(int j = 0; j < COLUMN; ++j)
        {   std::cout << tab[i][j] << "  ";
        }
        std::cout << "\n";
    }
 
 
    ///-----------------------------------|
    /// Чистим память.                    |
    ///-----------------------------------:
    for(int i = 0; i < ROW; ++i)
    {   delete[] tab[i];
    }
    delete[] tab;
 
    std::cin.get();
    return 0;
}

  const std::size_t pv_size = 3;
  const int possible_values[pv_size] { 0, 1, 3 };
  // ... init a, for i, for j
  a[i][j] = possible_values[rand() % pv_size];

#include <iostream>
#include <iomanip>
 
int main () {
  const size_t str = 10, 
    col = 10, 
    pv_size = 3;
  int a[str][col],
    c[str] = { 0 },
    possible_values[pv_size] = { 0, 1, 3 };
  int* b[str];
  
  for (size_t i = 0; i < str; i++) {
    b[i] = a[i];
    for (size_t j = 0; j < col; j++)
      c[i] += a[i][j] = possible_values[rand() % pv_size];
  }
  
  for (size_t i = 0; i < str - 1; i++)
    for (size_t j = i + 1; j < str; j++)
      if (c[i] < c[j])
        std::swap(c[i], c[j]),
        std::swap(b[i], b[j]);
 
  for (size_t i = 0; i < str; i++) {
    for (size_t j = 0; j < col; j++)
      std::cout << std::setw(4) << b[i][j];
    std::cout << std::endl;
  }
}