Функции-шаблоны для обработки массива

#include <iostream>
using namespace std;
 
template <typename X>
void printArray(char *name , X **a,int m, int n)
{
cout <<name;
for (int i=0; i<n; i++)
for (int j=0; j<m; j++){
cout<<"a["<<i<<"]["<<j<<"]"<<" ";
cin>>a[i][j];
}
cout<<endl;
}
 
 template <typename X>
X minArray(X **a,int m, int n)
{
    X min=10;
for (int i=0; i<n; i++)
   for (int j=0; j<m; j++)
    if (a[i][j]< min)
     a[i][j]*=2;
     for (int i=0; i<n; i++)
     for (int j=0; j<m; j++)
     return a[i][j];
}
 
int main()
{
int n; int m;
cin>>n;
cin>>m;
int**a = new int*[n];
for(int i=0; i<m; ++i)
 a[i] = new int[m];
for(int i=0; i<m; ++i)
 for(int j=0; j<n; ++j)
    int minA=minArray(a,n,m);
     printArray(a,n,m);
cout<<endl;
return 0;
}

cout << a[i][j] << " ";

template <typename X>
X minArray(X **a,int m, int n)
{
X min=a[0][0];
for(int i=0; i<n; i++)
    for(int j=1; j<m; j++)
        if(a[i][j]< min)
            min = a[i][j];
return min;
}

template <typename X>
void InputArray(X **a, int vn, int vm)
{
for(int i=0; i<vn; i++)
    for(int j=0; j<vm; j++)
    {
        cout << "Vvedite << "a["<<i<<"]["<<j<<"]"<<" element massiva:";
        cin >> a[i][j];
        cout << "\n";
    }
}

#include <cstddef>
 
namespace tools
{
    using std::size_t;
    
    template<typename T>
    struct RangeCreateImpl
    {
        using IterType = T;
        constexpr RangeCreateImpl(IterType it, size_t t) noexcept :
            iter_(it),
            off_(t)
        {}
        
        constexpr IterType begin()
        {
            return iter_;
        }
        
        constexpr IterType end()
        {
            return iter_ + off_;
        }
        
    private:
        IterType iter_;
        size_t off_;
    };
        
    template<typename T>
    constexpr RangeCreateImpl<T> createRange(T iter, size_t off)
    {
        return RangeCreateImpl<T>(iter, off);
    }
    
} //namespace tools
 
//------------------------------------------------------------------
//------------------------------------------------------------------
//------------------------------------------------------------------
 
#include <iostream>
 
template<typename T>
void printArrayImpl(T arr, size_t n, size_t m)
{
    for (const auto & row : tools::createRange(arr, n))
    {
        for (const auto & col : tools::createRange(row, m))
        {
            std::cout << col << " ";
        }
        std::cout << "\n";
    }
    
    std::cout << "\n";
}
 
template<typename T, size_t N, size_t M>
void printArray(T (&arr)[N][M])
{
    printArrayImpl<T(*)[M]>(arr, N, M);
}
 
template<typename T>
void printArray(T ** arr, size_t n, size_t m)
{
    printArrayImpl<T**>(arr, n, m);
}
 
template<typename T>
void enterArrayImpl(T arr, size_t n, size_t m)
{
    for (auto & row : tools::createRange(arr, n))
    {
        for (auto & col : tools::createRange(row, m))
        {
            std::cin >> col;
        }
    }
}
 
template<typename T, size_t N, size_t M>
void enterArray(T (&arr)[N][M])
{
    enterArrayImpl<T(*)[M]>(arr, N, M);
}
 
template<typename T>
void enterArray(T ** arr, size_t n, size_t m)
{
    enterArrayImpl<T**>(arr, n, m);
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    int ** arr = new int*[2] { new int[2]{ 1, 2 }, new int[2]{ 3, 4 } };
    int arr2[][2] { { 5, 6 }, { 7, 8 } };
    int arr3[2][2] { { 9, 10 }, { 11, 12 } };
    
    enterArray(arr3);
    
    printArray(arr, 2, 2);
    printArray(arr2);
    printArray(arr3);
    
    delete [] arr[0];
    delete [] arr[1];
    delete [] arr;
}

#include <iostream>
 
template <typename T>
void InputArr(T *arr, const size_t size)
{
    for (size_t i = 0; i < size; i++)
        std::cin >> arr[i];
}
 
template <typename T>
void InputArr(T **arr, const size_t M, const size_t N)
{
    for (size_t i = 0; i < M; i++)
        InputArr(arr[i], N);
}
 
template <typename T, size_t size>
void InputArr(T (&arr)[size])
{
    InputArr(arr, size);
}
 
template <typename T, size_t M, size_t N>
void InputArr(T (&arr)[M][N])
{
    for (auto &l : arr)
        InputArr(l);
}
 
template <typename T>
void OutputArr(const T *arr, const size_t size)
{
    for (size_t i = 0; i < size; i++)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}
 
template <typename T>
void OutputArr(T **arr, const size_t M, const size_t N)
{
    for (size_t i = 0; i < M; i++)
        OutputArr(arr[i], N);
    std::cout << std::endl;
}
 
template <typename T, size_t size>
void OutputArr(const T (&arr)[size])
{
    OutputArr(arr, size);
}
 
template <typename T, size_t M, size_t N>
void OutputArr(const T (&arr)[M][N])
{
    for (const auto &l : arr)
        OutputArr(l);
    std::cout << std::endl;
}
 
template <typename T, typename Fn>
void ProcessArr(T *arr, const size_t size, const Fn &fn)
{
    for (size_t i = 0; i < size; i++)
        fn(arr[i]);
}
 
template <typename T, typename Fn>
void ProcessArr(T **arr, const size_t M, const size_t N, const Fn &fn)
{
    for (size_t i = 0; i < M; i++)
        ProcessArr(arr[i], N, fn);
}
 
template <typename T, size_t size, typename Fn>
void ProcessArr(T (&arr)[size], const Fn &fn)
{
    ProcessArr(arr, size, fn);
}
 
template <typename T, size_t M, size_t N, typename Fn>
void ProcessArr(T (&arr)[M][N], const Fn &fn)
{
    for (auto &l : arr)
        ProcessArr(l, fn);
}
 
template <typename T>
class Functor
{
public:
    constexpr Functor(const T &val) : m_val(val) {}
    constexpr void operator()(T &x) const
    {
        if (x == m_val)
            x *= 2;
    }
 
private:
    const T m_val;
};
 
int main()
{
    constexpr size_t M = 3, N = 2;
    constexpr Functor<int> fn(2);
 
    int *dynArr = new int[M];
    InputArr(dynArr, M);
    ProcessArr(dynArr, M, fn);
    OutputArr(dynArr, M);
    delete[] dynArr;
 
    int statArr[M];
    InputArr(statArr);
    ProcessArr(statArr, fn);
    OutputArr(statArr);
 
    int **dyn2Arr = new int*[M];
    for (size_t i = 0; i < M; i++)
        dyn2Arr[i] = new int[N];
    InputArr(dyn2Arr, M, N);
    ProcessArr(dyn2Arr, M, N, fn);
    OutputArr(dyn2Arr, M, N);
    for (size_t i = 0; i < M; i++)
        delete[] dyn2Arr[i];
    delete[] dyn2Arr;
 
    int stat2Arr[M][N];
    InputArr(stat2Arr);
    ProcessArr(stat2Arr, fn);
    OutputArr(stat2Arr);
}