일단 각각의 문제를 나눠서 코멘트 쓰기보단 한번에 쓰는 게 좋을 듯 하여, 전체적으로 코드를 수정하고, 주석으로 코멘트를 달았습니다.

그리고 사실 new int[]를 통한 배열 할당보다는 std::vector 등의 STL을 이용하는 것이 좋지만, 거기까지 수정해버리면 원래 코드와 너무 달라질 듯 하여 알려만 드립니다.

#include <iostream>
#include <fstream>

#define FILENAME "data.txt"
#define MAXSIZE 60
using namespace std;

// 전역변수는 왠만하면 쓰지 않는 게 좋습니다.
// ifstream fin;
// ofstream fout;

class Matrix
{
public:
    Matrix();
    ~Matrix();
    // 함수 선언시 매개변수의 이름을 생략하는 건 좋지 않습니다.
    // 그리고 변수명은 일관성 있게 짓는 게 좋습니다.
    // 어떤 함수는 매개변수에 접두사(_)를 붙이고 어떤 함수는 안 붙이면, 헷갈리게 됩니다.
    Matrix(int _size, int _numOfElements, int* _row, int* _col, int* _value);
    Matrix(const Matrix& _rhs);
    Matrix& operator=(const Matrix& _rhs);

    void init(const Matrix& _rhs);
    void release();

    void getData(ifstream& _fin);
    void printData() const;
    void display() const;
    void sort();

    Matrix operator*(const Matrix& _rhs);

private:
    // 멤버 변수에는 적당한 접두사나 접미사를 붙이는 것이 좋습니다.
    // 함수 내에서 보기도 편하고, 지역변수와 이름이 겹치는 것을 피할 수 있습니다.
    int     mSize;
    int     mNumOfElements;
    int*    mRow;
    int*    mCol;
    int*    mValue;
};

// 메인 함수는 최대한 위쪽에 위치시키는 것이
// 전체코드 가독성에 있어서 좋다고 생각합니다.
int main()
{
    Matrix A, B, C;

    ifstream fin(FILENAME);
    A.getData(fin);
    B.getData(fin);
    fin.close();

    C = A * B;

    // 함수 호출을 한 줄에 여러번 쓰는 것은 좋지 않습니다.
    A.display();
    B.display();
    C.display();

    C.printData();

    cout << "Done !!" << endl;
    return 0;
}

// 함수 정의 순서는 선언 순서와 동일하게 유지하는 것이 좋습니다.
Matrix::Matrix()
    : mSize(0)
    , mNumOfElements(0)
    , mRow(nullptr)
    , mCol(nullptr)
    , mValue(nullptr)
{
    // 기본적인 멤버 변수의 초기화는
    // 생성자 초기화 리스트를 이용하는 게 좋습니다.
}

Matrix::~Matrix()
{
    // 문제1. 널체크를 변수 하나에 대해서만 했네요.
    // 문제2. 할당은 배열로 하고, 해제는 그냥 delete를 썼네요.
    // PS1. this->는 굳이 쓸 필요가 없습니다.
    // PS2. 널체크는 if(변수) 이런 식으로도 가능합니다.
    release();
}

Matrix::Matrix(int _size, int _numOfElements, int* _row, int* _col, int* _value)
    : mSize(_size)
    , mNumOfElements(_numOfElements)
    , mRow(_row)
    , mCol(_col)
    , mValue(_value)
{
    // 이 생성자가 호출되는 쪽을 보니, temp변수에 new를 해서 이걸 호출하고,
    // 여기서 또 new 해서 복사한다음에 temp변수를 delete하던데,
    // 굳이 그럴필요 없이 포인터를 그대로 옮겨주면 될 듯합니다.
}

Matrix::Matrix(const Matrix& _rhs)
    : mSize(0)
    , mNumOfElements(0)
    , mRow(nullptr)
    , mCol(nullptr)
    , mValue(nullptr)
{
    // 문제3. 여기도 널체크가 변수 하나에만 되어있었습니다.
    // 문제4. new int()는 배열 할당이 아닙니다.
    // 문제5. _rhs.mNumOfElements의 값이 0이하 라면 문제가 생깁니다.
    //        따라서, 그때는 빈 객체로 남도록 해야합니다.
    init(_rhs);
}

Matrix& Matrix::operator=(const Matrix& _rhs)
{
    // PS3. 복사 생성자와 복사 대입 연산자를 구현할 때는,
    //      중복되는 코드를 사용하게 되니, 초기화와 메모리 해제를 함수로 추출하여
    //      해당 함수들을 호출하도록 해주는 것이 좋습니다.
    release();
    init(_rhs);
    return *this;
}

void Matrix::init(const Matrix& _rhs)
{
    if (_rhs.mNumOfElements > 0
        && _rhs.mRow != nullptr
        && _rhs.mCol != nullptr
        && _rhs.mValue != nullptr)
    {
        mSize = _rhs.mSize;
        mNumOfElements = _rhs.mNumOfElements;
        mRow = new int[mNumOfElements];
        mCol = new int[mNumOfElements];
        mValue = new int[mNumOfElements];

        for (int i = 0; i < mNumOfElements; i++)
        {
            mRow[i] = _rhs.mRow[i];
            mCol[i] = _rhs.mCol[i];
            mValue[i] = _rhs.mValue[i];
        }
    }
}

void Matrix::release()
{
    if (mRow) delete[] mRow;
    if (mCol) delete[] mCol;
    if (mValue) delete[] mValue;
}

void Matrix::getData(ifstream& _fin)
{
    _fin >> mSize;
    _fin >> mNumOfElements; // 어차피 이 변수는 size * size 인듯 하니, 따로 읽을 필요는 없어 보입니다.
    // 위의 데이터 읽기에 실패한다면, 아래 코드들을 실행하면 안 되기 때문에
    // 예외처리를 추가했습니다.
    if (mSize < 1 || mNumOfElements < 1)
        return;

    mRow = new int[mNumOfElements];
    mCol = new int[mNumOfElements];
    mValue = new int[mNumOfElements];

    for (int i = 0; i < mNumOfElements; i++)
    {
        _fin >> mRow[i] >> mCol[i] >> mValue[i];
    }
    // 여기서 sort 함수를 호출하는 의미는 잘 모르겠습니다..
    sort();
}

void Matrix::printData() const
{
    // 파일 오픈시 ios::ate 플래그를 주면,
    // 파일에 이미 있는 데이터에 이어서 쓰기 작업을 진행할 수 있습니다.
    ofstream fout("resultMatrix.txt", ios::ate);
    fout << mSize << endl;
    fout << mNumOfElements << endl;
    for (int i = 0; i < mNumOfElements; i++)
    {
        fout << mRow[i] << " " << mCol[i] << " " << mValue[i] << endl;
    }
    fout.close();
}

void Matrix::display() const
{
    cout << "The Matrix is : " << endl;
    for (int i = 0; i < mNumOfElements; i++)
    {
        cout << mRow[i] << " " << mCol[i] << " " << mValue[i] << endl;
    }
}

void Matrix::sort()
{
    // 문제6. 가장 바깥의 for문에 스코프({})가 없습니다.
    // 문제7. 한 줄에 여러 코드가 들어가 있어서 가독성이 떨어집니다.
    // PS4. 중복되는 패턴의 코드들은 함수로 추출하는 게 좋지만,
    //      추가적인 함수를 만들어드리면, 원래코드랑 너무 차이가 생길 듯 하여 주석만 남깁니다.
    int tempRow, tempCol, tempValue;
    for (int i = 0; i < mNumOfElements; i++)
    {
        for (int j = i + 1; j < mNumOfElements; j++)
        {
            if (mRow[i] > mRow[j])
            {
                // swap(mRow[i], mRow[j]); 이런 식의 코드로 변경하는 것이 좋을 듯 합니다.
                tempRow = mRow[i];
                mRow[i] = mRow[j];
                mRow[j] = tempRow;

                tempCol = mCol[i];
                mCol[i] = mCol[j];
                mCol[j] = tempCol;

                tempValue = mValue[i];
                mValue[i] = mValue[j];
                mValue[j] = tempValue;
            }
            else if (mRow[i] == mRow[j])
            {
                if (mCol[i] > mCol[j])
                {
                    tempRow = mRow[i];
                    mRow[i] = mRow[j];
                    mRow[j] = tempRow;

                    tempCol = mCol[i];
                    mCol[i] = mCol[j];
                    mCol[j] = tempCol;

                    tempValue = mValue[i];
                    mValue[i] = mValue[j];
                    mValue[j] = tempValue;
                }
            }
        }
    }
}

Matrix Matrix::operator*(const Matrix& _rhs)
{
    int newNumOfElements = 0;
    int notAdded = 1;

    // 변수 선언과 동시에 값을 대입하는 것이 좋습니다.
    int* tempRow = new int[mSize * mSize];
    int* tempValue = new int[mSize * mSize];
    int* tempCol = new int[mSize * mSize];

    // (const Matrix&) 캐스팅은 필요 없는 코드입니다.
    Matrix rhs(_rhs);

    // 여기도 swap함수를 쓰는 게 좋을 듯 합니다.
    // transpose
    int* temp = rhs.mRow;
    rhs.mRow = rhs.mCol;
    rhs.mCol = temp;

    // 아래 알고리즘이 제대로 동작하는 지까지는 검증하지 않았습니다.
    // 제대로 작성하셨다고 가정하고 넘어가겠습니다.
    // multiply
    for (int i = 0; i < mNumOfElements; i++)
    {
        for (int j = 0; j < rhs.mNumOfElements; j++)
        {
            notAdded = 1;
            if (mCol[i] == rhs.mCol[j])
            {
                for (int k = 0; k <= mNumOfElements - 1; k++)
                {
                    if (tempRow[k] == mRow[i] && tempCol[k] == rhs.mRow[j])
                    {
                        tempValue[k] += mValue[i] * rhs.mValue[j];
                        notAdded = 0;
                    }
                }
                if (notAdded)
                {
                    tempRow[newNumOfElements] = mRow[i];
                    tempCol[newNumOfElements] = rhs.mRow[j];
                    tempValue[newNumOfElements] = mValue[i] * rhs.mValue[j];
                    newNumOfElements++;
                }
            }
        }
    }

    // temp 변수들은 그대로 새 객체에게 넘겨줬기 때문에
    // 여기서 delete[] 해줄 필요가 없습니다.
    // 하지만, 1,2번째 인자가 문제가 없는지는 애매합니다.
    // 위의 알고리즘과 함께 다시 한번 검증해보셔야 할 듯 합니다.
    Matrix ans(_rhs.mSize, newNumOfElements, tempRow, tempCol, tempValue);
    //ans.display();
    return ans;
}