Sorting multidimensional array in c++

Your issue may be easier resolved by changing your data structures. Instead of having an array of arrays, have an array of structures. The structure would contain the sum and the array of values.

struct Row
{
  int sum;
  std::vector<int> values;
};

Row data[5];

With this concept, you are sorting the rows by their sums.
You can easily write a comparator for this and use std::sort:

bool Compare_Rows(const Row& a, const Row &b)
{
  return a.sum < b.sum;
}

//...
std::sort(&data[0], &data[5], Compare_Rows);

Edit 1 -- Overloading operator <
You could simplify and not require a comparator by providing an overloaded operator <:

struct Row
{
  int sum;
  std::vector<int> values;

  bool operator<(const Row& other)
  {
    return sum < other.sum;
  }
};

The sorting call now becomes:

std::sort(&data[0], &data[5]);

Here's how I would approach the problem:

Write a swap function which switches two rows in a multidimensional array. Something like:

// columns is the number of columns; ie array[rows][columns]
void swap(int[][] array, const int columns, int switch1, int switch2)
{
    for (int i = 0; i < columns; i++)
        array[switch1][i] ^= array[switch2][i] ^= array[switch1][i] ^ array[switch2][i];
}

Then, write a sum function, which adds all elements in a row. Something like:

int sumCol(int[][] array, int columns, int index)
{
    int sum = 0;
    for (int i = 0; i < columns; i++)
        sum += array[index][i];
    return sum;
}

Finally, write a sort function which is able to sort a multidimensional array using the following operations:

• Comparing the sum of two rows
• Swapping two rows

I'll leave it up to your preference to decide which sorting algorithm to use.

I have to create two dimensional array

I don't know what you mean by this (do you have to read it from some input, or populate it with numbers etc. ?), but lets say you create a two dimensional matrix like this:

// Just a type alias for the matrix.
template <typename T, std::size_t R, std::size_t C>
using Matrix = std::array<std::array<T, C>, R>;

// Create two dimensional matrix [3][3] of ints.
Matrix<int, 3, 3> matrix = {{ { 2, 3, 4 },
                              { 7, 8, 9 },
                              { 5, 6, 7 } }};

Then you can sort the matrix by the sum of each row in descending order like in the following example. I have used std::sort together with a custom comparator functor (created with a lambda function):

std::sort(std::begin(matrix), std::end(matrix), [] (decltype(*matrix.cbegin())& lhs, decltype(*matrix.cbegin())& rhs) {
    return std::accumulate(std::begin(lhs), std::end(lhs), 0) > std::accumulate(std::begin(rhs), std::end(rhs), 0);
});

That's it.

Now let's output the matrix:

for (decltype(matrix.size()) row = 0; row != matrix.size(); ++row) {
    std::cout << row + 1 << ". ";
    for (const auto i : matrix[row]) {
        std::cout << i << " ";
    }
    std::cout << std::accumulate(std::begin(matrix[row]), std::end(matrix[row]), 0);
    std::cout << std::endl;
}

Live example