Поиск минимального и максимального элемента в матрице

#ifndef _LIBRARYMATRIX_H_
#define _LIBRARYMATRIX_H_
#include <iostream>
using namespace std;
 
template <typename T>
class matrix
{
    int *p_m;
    T n;
public:
    matrix(T count_n);
    matrix(const matrix & m);
    matrix operator+(const matrix my);
    matrix operator-(const matrix my);
    matrix operator*(const matrix my);
    matrix operator/(const matrix my);
    void operator=(const matrix my);
    void In_put();
    void Out_put();
    int get_n() const { return n; }
    void set(T *p_n1 = 0) { *p_n = *p_n1; }
    void MinMax(const matrix & s);
    ~matrix();
};
template <typename T>
matrix <T> matrix<T>::operator+(const matrix my)
{
    int my_n = (n*n - n) / 2 + n;
    matrix m_ret(n);
    for (int i = 0;i<my_n;i++)
        m_ret.p_m[i] = p_m[i] + my.p_m[i];
    return m_ret;
};
 
template <typename T>
matrix<T> matrix<T>::operator-(const matrix my)
{
    int my_n = (n*n - n) / 2 + n;
    matrix m_ret(n);
    for (int i = 0;i<my_n;i++)
        m_ret.p_m[i] = p_m[i] - my.p_m[i];
    return m_ret;
};
 
template <typename T>
matrix<T> matrix<T>::operator/(const matrix my)
{
    T my_n = (n*n - n) / 2 + n;
    matrix m_ret(n);
    for (int i = 0;i<my_n;i++)
        m_ret.p_m[i] = p_m[i] / my.p_m[i];
    return m_ret;
};
 
 
template <typename T>
void matrix<T>::operator=(const matrix my)
{
    int my_n = (n*n - n) / 2 + n;
    for (int i = 0;i<my_n;i++)
        p_m[i] = my.p_m[i];
};
 
template <typename T>
matrix<T> matrix<T>::operator*(const matrix my)
{
    int my_n = (n*n - n) / 2 + n;
    matrix m_ret(n);
    for (int i = 0;i<my_n;i++)
        m_ret.p_m[i] = p_m[i] * my.p_m[i];
    return m_ret;
}
 
 
template <typename T>
matrix<T>::matrix(T count_n)
{
    n = count_n;
    int my_n = (n*n - n) / 2 + n;
    p_m = new int[my_n];
    for (int i = 0;i < my_n;i++)
        p_m[i] = rand() % 10;
};
 
 
template <typename T>
matrix<T>::matrix(const matrix & m)
{
    n = m.n;
    T my_n = (n*n - n) / 2 + n;
    p_m = new int[my_n];
    for (int i = 0;i<my_n;i++)
        p_m[i] = m.p_m[i];
};
 
template <typename T>
matrix<T>::~matrix()
{
};
template <typename T>
void matrix<T>::MinMax(const matrix & m)
{
    int min = m.p_m[0];
    for (int  i = 1; i < 20; i++)
        if (min > m.p_m[i])
        {
            int temp = m.p_m[i];
            m.p_m[i] = min;
            min = temp;
        }
    cout << min;
}
 
template <typename T>
void matrix<T>::Out_put()
{
    int y = 0, out_ch = 0;
    for (int i = 0;i<n;i++)
    {
        for (int k = 0;k<y;k++)
        {
            cout.width(4);
            cout << "0";
        }
        for (int j = 0;j<n - y;j++)
        {
            cout.width(4);
            cout << p_m[out_ch];
            out_ch++;
        }
        cout << "\n";
        y++;
    }
};
 
 
template <typename T>
void matrix<T>::In_put()
{
    T y = 0;
    int in_ch = 0;
    for (int i = 0;i<n;i++)
    {
        for (int j = 0;j < n - y;j++)
        {
            cout << "[" << i << "," << j << "]: ";
            cin >> p_m[in_ch];
            in_ch++;
        }
        y++;
    }
};
 
#endif

struct Minmax
{
    int m_min = 0;
    int m_max = 0;
};
 
T matrix<T>::find_min_value()
{
    T min_value = p_m[0][0];
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            if (min_value > p_m[i][j])
                min_value = p_m[i][j];
    return min_value;
}
 
T matrix<T>::find_max_value()
{
    T max_value = p_m[0][0];
    for (int i = 0; i < m_row; ++i)
        for (int j = 0; j < m_col; ++j)
            if (max_value < p_m[i][j])
                max_value = p_m[i][j];
    return max_value;
}
 
 
Minmax matrix<T>::min_max(const matrix &  matr)
{
    Minmax result;
    result.m_min = matr.find_min_value();
    result.m_max = matr.find_max_value();
    
    return result;
}