Mathematical matrices implementation
There is a bug in your Matrix destructor. delete array is not correct. It was allocated using an array form of the new operator, so it must be deleted using an array form of delete(that is, delete[]). The current version of your code invokes undefined behavior. But simply changing it to delete[] array is not enough to fix it. There is still a memory leak here. A correct version of the destructor should look this way:

~Matrix() {
    for (int row = 0; row &lt; n; row++)
        delete[] array[row];
    delete[] array;
}


It is necessary because deleting an array of pointers does not delete the objects pointed by this pointers.  
It looks like the size of the array is not correct, either. You allocate an array of pointers of size n, but then you use it as if it had a size m.

array = new int*[n];
for (int i = 0; i &lt; n; i++)
    array[i] = new int[m];
...
for (int i = 0; i &lt; res-&gt;m; i++) {
    for (int j = 0; j &lt; res-&gt;n; j++) {
        res-&gt;array[i][j] = m1-&gt;array[i][j] + m2-&gt;array[i][j];
    }
}


This code invokes undefined behavior in case n != m.
You should probably implement a copy constructor and a copy-assignment operator. A default copy constrcutor(and assignment operator) just copies the pointer, not the content of the Matrix(I'm not sure if you it is what you want). 
A good way to get rid of many bugs in your code is to use standard containers instead of dynamic memory allocation with raw pointers. For example, you can use a std::vector to store the elements of the Matrix:

 class Matrix {
     std::vector&lt;std::vector&lt;int&gt;&gt; array;
     ...
 };


It allows you to avoid manual memory management issues.
Using raw pointers and the new operator is not common in modern C++ in general.
C++ has operator overloading, and it is usually used in C++ programs. For example, matrix addition is a good candidate for overloading the + operator. 

class Matrix {
    ...
public:
    Matrix operator+(const Matrix&amp; rhs) const {
        // Check the validity of input parameters.
        Matrix res(n, m);
        // Addition goes here.
        return res;
    }

    ...
};


This example also shows a conventional way to pass arguments without copying them: by const reference(passing a pointer to them is not common in modern C++).
Member-functions that do not change the instance should have a const qualifier. 
It is a good practice to write unit tests instead of ad-hoc testing(it is not C++ specific, of course).