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

#include <stdio.h>
 
void scan_matrix(int* b, int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
            scanf("%d", b + i * n + j);
    }
};
 
 
void print_matrix(int* b, int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
            printf("%d ", *(b + i * n + j));
        printf("\n");
    }
};
 
int main()
{
    int n;
    scanf("%d", &n);
    int arr[n][n] = {0};
    scan_matrix(&arr[0][0], n);
    for (int i = 0; i < n; i++)
    {
        int (*b) [n] = &arr[i];
        int (*p) [n] = &arr[n - i - 1];
        for (int j = 0; j < n; j++)
        {
            int* d = b[0];
            int* q = p[0];
            *(d) += *(q);
            *(q) = *(d) - *(q);
            *(d) -= *(q);
        }
    }
    printf("\n");
    print_matrix(&arr[0][0], n);
    return 0;
}

// отражение строк матрицы по вертикали
int** reflect_rows(int** matrix, size_t rows)
{
  assert(matrix && rows);
  int **up_ptr = matrix, **dn_ptr = up_ptr + rows - 1;
  while (up_ptr < dn_ptr) swap(*up_ptr++, *dn_ptr--);
  return matrix;
}

#include <iostream>
 
int main()
{
    int n = 0;
    std::cin >> n;
 
    int **arr = new int*[n];
    for (int *row = arr; row < arr + n; ++row) {
        *row = new int[n];
        for (int *el = *row; el < *row + n; ++el) {
            std::cin >> *el;
        }
    }
 
    int *beg = arr;
    int *end = arr + n;
    while (beg < end) {
        int *tmp = beg;
        beg = --end;
        end = tmp;
        ++beg;
    }
 
    for (int *row = arr; row < arr + n; ++row) {
        for (int *el = *row; el < *row + n; ++el) {
            std::cout << *el << " ";
        }
        std::cout << std::endl;
        delete row;
    }
 
    delete arr;
 
    return 0;
}

print_matrix(&arr[0][0], n);

void print_matrix(int* b, int n)

#include <iostream>
#include <ctime>
#include <cassert>
 
using namespace std;
 
/* Пример преобразования:
    Входные данные:
    1 2 3 4
    1 2 3 4
    4 5 6 4
    4 5 6 4
    
    Правильные выходные данные:
    4 5 6 4
    4 5 6 4
    1 2 3 4
    1 2 3 4 */
 
// магические вычисления :)))
inline size_t dec_width(size_t x)
{
  size_t w = 1;
  while (x /= 10) w++;
  return w;
}
 
// создание матрицы и заполнение её случайными числами
int** new_matrix(size_t rows, size_t cols)
{
  int** x = new int*[rows];
  for (int row = 0; row != rows; row++)
  {
    x[row] = new int[cols];
    for (auto col = 0; col != cols; col++)
      x[row][col] = rand() % 2000;
  }
  return x;
}
 
// удаление матрицы
void free_matrix(int** src, size_t rows)
{
  for (int row = 0; row != rows; row++) delete []src[row];
  delete []src;
}
 
// вывод матрицы в консоль
void print_matrix(int** src, size_t rows, size_t cols, const char* header)
{
  unsigned *widths = new unsigned[cols];
  for (int col = 0; col != cols; col++)
  {
    widths[col] = 1;
    for (int row = 0; row != rows; row++)
    {
      size_t cw = dec_width(src[row][col]);
      if (cw > widths[col]) widths[col] = cw;
    }
  }
 
  printf("\n%s [%lu x %lu]:\n", header, rows, cols);
  for (int row = 0; row != rows; row++)
  {
    for (int col = 0; col != cols; col++) printf(" %*d", widths[col], src[row][col]);
    printf("\n");
  }
 
  delete []widths;
}
 
// отражение строк матрицы по вертикали
int** reflect_rows(int** matrix, size_t rows)
{
  assert(matrix && rows);
  int **up_ptr = matrix, **dn_ptr = up_ptr + rows - 1;
  while (up_ptr < dn_ptr) swap(*up_ptr++, *dn_ptr--);
  return matrix;
}
 
#define DEFAULT_ROWS 4
#define DEFAULT_COLS 5
#define USER_INPUT
 
int main()
{
  srand(time(0));
  unsigned rows = DEFAULT_ROWS, cols = DEFAULT_COLS;
  
  // ввод размеров вручную
  #ifdef USER_INPUT
  cout << "? Rows and Cols: ";
  cin >> rows >> cols;
  
  if (!cin.good()) return -1; // обшыбка ввода 
  if (!rows || !cols) return -2; // недопустимые размеры
  #endif
 
  int **x = new_matrix(rows, cols);
  
  print_matrix(x, rows, cols, "# source matrix");
  print_matrix(reflect_rows(x, rows), rows, cols, "# dest matrix");
  
  free_matrix(x, rows);
  
  return 0;
}