Двоичный (бинарный) поиск элемента в двумерном массиве

#include <windows.h>
#include <iostream>
#include <iomanip>
using namespace std;
template <typename T>
void func1(T ar[][50], int n, int m);
template <typename T>
int search2(T ar[][50], int n, int m);
 
 
void main()
{
 
    setlocale(LC_ALL, "russian");
    setlocale(0, "");
    srand(time(NULL));
 
    int n2, m2;
    const int row = 50; const int col = 50;
    int ar1i[row][col]; 
 
    
    //Написать функцию, реализующую алгоритм бинарного поиска заданного ключа в двухмерном массиве
    cout << "Введите размеры двухмерного массива:" << endl;
    cin >> n2 >> m2;
    func1(ar1i, n2, m2);
    search2(ar1i, n2, m2);
 
 
 
 
}
 
 
template <typename T>
void func1(T ar[][50], int n, int m)
{
    cout << endl;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            ar[i][j] = (rand() % 26 + 65) + ((rand() % 100) / 100.0);
            cout << ar[i][j] << "   ";
        }
        cout << endl << endl;;
    }
}
template <typename T>
int search2(T ar[][50], int n, int m)
{
    T key;
    int mid;
    cin >> key;
    while (1)
    {
        mid = (n + m) / 2;
        if (key < ar[mid][50])
        {
            m = mid - 1;
        }
        if (key > ar[mid][50])
        {
            n = mid + 1;
        }
        else return mid;
        if (n > m)
            return -1;
    }
}

#include <cstdlib>
#include <iostream>
using namespace std;
 
template <typename vectorT>
void quick_sort(vectorT & v, const int a, const int b) {
   int i = a, j = b;
   
   // Здесь подразумевается что элементы вектора целые числа
   int x = v[ (i+j)/2 ];
   do {
      while (v[i] < x) ++i;
      while (v[j] > x) --j;
 
      if (i <= j) {
         if (i < j) swap(v[i], v[j]);
         ++i, --j;
      }
   } while (i <= j);
 
   if (i < b) quick_sort(v, i, b);
   if (a < j) quick_sort(v, a, j);
}
 
template <typename vectorT>
bool bin_search(vectorT & v, int size, int x) {
   int l = 0, r = size-1;
 
   while (l <= r) {
      int m = (l+r)/2;
      //cout << l << ' ' << m << ' ' << r << endl;
 
      if (x < v[m]) {
         r = m-1;
      } else if (x > v[m]) {
         l = m+1;
      } else {
         return true;
      }
   }
 
   return false;
}
 
// Инкапсуляция матрицы
template <typename T, const int N, const int M>
class matrix {
   public:
      T & operator[](int i) {
         return at(i);
      }
 
      // Обращение к массиву как к одномерному
      T & at(int i) {
         return a[i/M][i%M];
      }
 
      // Обращение к массиву как к двумерному
      T & at(int x, int y) {
         return a[x][y];
      }
 
   private:
      T a[N][M];
};
 
int main() {
   const int m_size = 3;
   matrix<int, m_size, m_size> m;
 
   for (int i = 0; i < m_size*m_size; ++i)
      m.at(i) = rand()%100;
 
   quick_sort(m, 0, m_size*m_size-1);
 
   for (;;) {
      for (int i = 0; i < m_size; ++i) {
         cout << "( ";
         for (int j = 0; j < m_size; ++j)
            cout << m.at(i, j) << " ";
         cout << ")\n";
      }
 
      int n;
      cin >> n;
      if (n == 0) break;
 
      if (bin_search(m, m_size*m_size, n)) {
         cout << "THERE IS" << endl;
      } else {
         cout << "THERE IS NO" << endl; 
      }
   }
 
   return 0;
}