How to reset two-dimensional array to its original form after sorting?

Question

I am trying to reset 2D array to its original form after it's been sorted with a bubble sort. I need to reset it back to what it was before sorting. How do I do it? In case you have a question why an array is global. It's a school assignment and that's how our professor wants us to do it. Here is my program:

 #include<iostream>

    using namespace std;
    const int NUM_COLS=4;
    const int NUM_ROWS=5;       

    int array[NUM_ROWS][NUM_COLS]={{5, 3, 2, 16},
                            {9, 8, 10, 17},
                            {4, 7, 11, 18},
                            {2, 5, 9, 12},
                        {7, 9, 4, 10}};

it sorts an array with bubbleSort

void bubbleSort(int row, int col){}

it is display array function header

void displayArray(){}

and here is main function

int main(){



        cout<<"original array"<<endl;
        displayArray();

        bubbleSort(NUM_ROWS-1, NUM_COLS);
        cout<<"\nbubble sort"<<endl;
        displayArray();

        reset();
        displayArray();
        return 0;
    }

Now I need to reset an array back to original. I did this but it doesn't work.

void reset(){

 int array[NUM_ROWS][NUM_COLS]={{5, 3, 2, 16},
                                {9, 8, 10, 17},
                                {4, 7, 11, 18},
                                {2, 5, 9, 12},
                                {7, 9, 4, 10}};
}

Answer 1

Your reset is declaring a new array (and doing nothing with it). You can't assign (=) C style arrays, so you will need something that looks different. If you can use std::array instead, you could assign in reset.

#include <array>

const int NUM_COLS=4;
const int NUM_ROWS=5;       

std::array<std::array<int, NUM_ROWS>, NUM_COLS> values = {
    {5, 3, 2, 16},
    {9, 8, 10, 17},
    {4, 7, 11, 18},
    {2, 5, 9, 12},
    {7, 9, 4, 10}};

// Other code probably remains unchanged

void reset() {
    values = {
        {5, 3, 2, 16},
        {9, 8, 10, 17},
        {4, 7, 11, 18},
        {2, 5, 9, 12},
        {7, 9, 4, 10}};
}

At which point you notice that you've got your bounds the wrong way round, and it should either be

const int NUM_COLS=5;
const int NUM_ROWS=4;       

or a differently shaped array initialiser.

Answer 2

void reset(){
  static int original[NUM_ROWS][NUM_COLS]={{5, 3, 2, 16},
                                {9, 8, 10, 17},
                                {4, 7, 11, 18},
                                {2, 5, 9, 12},
                                {7, 9, 4, 10}};

  for (int i = 0; i < NUM_ROWS; i++)
    memcpy(array[i], original[i], NUM_COLS * sizeof(int));
}

Not the prettiest thing, but this should work. Since that's how your professor wants you to do it, go for it ¯\_(ツ)_/¯

Answer 3

As I said in a comment, the easiest way to assign arrays is to wrap them in a structure. Voilà, suddenly C++ develops abilities it didn't even know it had inherited from C and copies arrays!¹ Even nested, multi-dimensional arrays!

#include <iostream>
#include <iomanip>
#include <algorithm>
using namespace std;

const int NUM_COLS=4;
const int NUM_ROWS=5;       

// Define a struct (i.e., a class with all public members)
// which has just a single member, the array. Note that this is
// only a *type* declaration, no object is created yet.
struct arrT
{
  int array [NUM_ROWS][NUM_COLS];
};

// object creation.
arrT workArr;

void reset()
{
  // The initialization value is hidden inside the function.
  // static variables are initialized only once, for constant 
  // data at compile time.
  static const arrT oriArr 
  {
    { {5, 3, 2, 16},
      {9, 8, 10, 17},
      {4, 7, 11, 18},
      {2, 5, 9, 12},
      {7, 9, 4, 10}
    }
  };

  workArr = oriArr; // simple default assignment of structs
}

// The parameters are redundant.
void stdSort(int /*row*/, int /*col*/)
{ 
  // Sort the 2D array as a one-dimensional sequence
  // (which the elements are in memory).
  // The algorithm expects iterators to the first and
  // one-after-the-last elements in the sequence. Pointers
  // to the elements in an array are perfectly good iterators.
  std::sort(&workArr.array[0][0], &workArr.array[NUM_ROWS-1][NUM_COLS]);
}

void displayArray()
{
  // The top-level elements of a 2D array are the rows...
  for(auto &row: workArr.array)
  {
    // ... and the elements of the rows are ints. 
    // Note how the
    // dimensions are known from the class declaration.
    for(auto &el: row)
    {
      cout << setw(4) << el;
    }
    cout << "\n";
  }
}

int main(){

  cout << "Work array before initialization:\n";
  displayArray();

  reset(); // before, the values of the global array are 0.
  cout<<"\nWork array after init:\n";
  displayArray();

  stdSort(NUM_ROWS, NUM_COLS);
  cout<<"\nWork array after std sort"<<endl;
  displayArray();

  reset();
  cout << "\nWork array after reset\n";
  displayArray();
  return 0;
}

---

_{¹ Arrays are the only example I know of off the cuff where the memberwise assignment of the generated default assignment operator can assign a type which does not have a standalone assignment operator (which is the exact reason we jump through this hoop). Are there others?}