This is the implementation of merge sort below. However, I don’t understand how this code even works. We don’t use pointers and nothing is returned in main(). So, how does it manipulate myarray? Can anyone explain?

Here is the code:

#include < iostream >
using namespace std;

void merge(int arr[], int l, int m, int r) {
  int i = l;
  int j = m + 1;
  int k = l;

  /* create temp array */
  int temp[5];

  while (i <= m && j <= r) {
    if (arr[i] <= arr[j]) {
      temp[k] = arr[i];
      i++;
      k++;
    } else {
      temp[k] = arr[j];
      j++;
      k++;
    }

  }

  /* Copy the remaining elements of first half, if there are any */
  while (i <= m) {
    temp[k] = arr[i];
    i++;
    k++;

  }

  /* Copy the remaining elements of second half, if there are any */
  while (j <= r) {
    temp[k] = arr[j];
    j++;
    k++;
  }

  /* Copy the temp array to original array */
  for (int p = l; p <= r; p++) {
    arr[p] = temp[p];
  }
}

mergeSort function:

/* l is for left index and r is right index of the 
   sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r) {
  if (l < r) {
    // find midpoint
    int m = (l + r) / 2;

    // recurcive mergesort first and second halves 
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);

    // merge
    merge(arr, l, m, r);
  }
}

Main function:

int main() {
  int myarray[5];
  //int arr_size = sizeof(myarray)/sizeof(myarray[0]);
  int arr_size = 5;

  cout << "Enter 5 integers in any order: " << endl;
  for (int i = 0; i < 5; i++) {
    cin >> myarray[i];
  }
  cout << "Before Sorting" << endl;
  for (int i = 0; i < 5; i++) {
    cout << myarray[i] << " ";
  }
  cout << endl;
  mergeSort(myarray, 0, (arr_size - 1)); // mergesort(arr,left,right) called

  cout << "After Sorting" << endl;
  for (int i = 0; i < 5; i++) {
    cout << myarray[i] << " ";
  }

  return 0;
}

>Solution :

This program uses two obscure features of C++ that were acquired from C for backwards compatibility.

1. Array-to-pointer decay. In most contexts, mentioning an array name is actually a shorthand of taking the address of the array’s first element. Thus, mergeSort(myarray, ...) is the same as mergeSort(&myarray[0], ...).
2. Function parameter type adjustments. You cannot pass an array to a function by value, so what does void mergeSort(int arr[], ...) ever mean? Just like in C, a function parameter of type array-of-something gets adjusted to pointer-to-something. So this function is exactly the same as void mergeSort(int* arr, ...)

So this program does use pointers after all, they are just thinly veiled.

The features mentioned above are essential for dealing with C-style arrays. C++ has alternatives to C-style arrays, namely std::array and std::vector, which are usually recommended in most cases.