Утечка памяти (решение СЛАУ методом Крамера, матрицы, malloc)

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>
using namespace std;
 
#define MTYPE double
 
int lec = 0, led = 0, lesc = 0, lesd = 0, cvc = 0, cvd = 0, mc = 0, md = 0; // LE constructor, LE destructor, LES constructor...
 
void mcrash() {
    cout << "Not enough memory." << endl;
    exit(-1);
}
 
string tstr(MTYPE c) {
    std::stringstream sstm;
    sstm << c;
    return sstm.str();
}
 
class Matrix {
public:
    MTYPE** data;
    int size;
 
    Matrix(int n) {
        size = n;
        data = (double**) malloc(sizeof(MTYPE) * size * size);
        if (!data)
            mcrash();
        for (int i = 0; i < size; i++) {
            data[i] = (double*) malloc(sizeof(MTYPE) * size);
            if (!data[i])
                mcrash();
            for (int k = 0; k < size; k++)
                data[i][k] = 0;
        }
        mc++;
    }
 
    void set(int i, int k, MTYPE val) {
        data[i][k] = val;
    }
 
    MTYPE get(int i, int k) {
        return data[i][k];
    }
 
    Matrix* cut(int n) {
        Matrix* nm = new Matrix(size - 1);
        //cout << endl;
        for (int i = 1; i < size; i++) {
            for (int k = 0; k < size; k++) {
                if (n == k)
                    continue;
                int nk = k > n ? k - 1 : k;
                //cout << i - 1 << " " << nk << " " << get(i, k) << endl;
                nm->set(i - 1, nk, get(i, k));
            }
        }
        //cout << endl;
        return nm;
    }
 
    MTYPE get_determinant() {
        if (size == 1)
            return data[0][0];
        else if (size == 2)
            return data[1][1] * data[0][0] - data[1][0] * data[0][1];
        else {
            MTYPE res = 0;
            for (int i = 0; i < size; i++) {
                Matrix* mcut = cut(i);
                res += (i % 2 == 0 ? 1 : -1) * get(0, i)
                        * mcut->get_determinant();
                delete mcut;
            }
            return res;
        }
    }
 
    ~Matrix() {
        md++;
        for (int i = 0; i < size; i++)
            free(data[i]);
        free(data);
    }
};
 
class ConstValue {
public:
    char var;MTYPE value;
 
    ConstValue() {
        var = 0;
        value = 0;
        cvc++;
    }
 
    ConstValue(char v, MTYPE v2) {
        var = v;
        value = v2;
        cvc++;
    }
 
    ~ConstValue() {
        cvd++;
        var = '\0';
        value = 0;
    }
};
 
class LinearEquation {
public:
    MTYPE result;
    ConstValue* left_part;
 
    int size;
 
    LinearEquation(int _n, MTYPE _result) {
        size = _n;
        left_part = (ConstValue*) calloc(_n, sizeof(ConstValue));
        if (!left_part)
            mcrash();
        result = _result;
 
        lec++;
    }
 
    void set(int n, ConstValue cv) {
        left_part[n] = cv;
    }
 
    ~LinearEquation() {
        led++;
        result = 0;
        free(left_part);
    }
};
 
class LinearEquationSystem {
public:
    LinearEquation* equations;
    int size;
 
    LinearEquationSystem(int _size) {
        size = _size;
        equations = (LinearEquation*) malloc(size * sizeof(LinearEquation));
        lesc++;
    }
 
    ~LinearEquationSystem() {
        lesd++;
        size = 0;
        free(equations);
    }
 
    Matrix* get_main_matrix() {
        Matrix* m = new Matrix(size);
        for (int i = 0; i < size; i++)
            for (int k = 0; k < size; k++)
                m->set(i, k, equations[i].left_part[k].value);
        return m;
    }
 
    Matrix* get_nth_matrix(int n, Matrix* mainMatr) {
        Matrix* m = get_main_matrix(); // Calling get_main_matrix() every time instead of cloning mainMatr is horribly inefficient.. TODO: Matrix* m = clone(mainMatr);
 
        //Matrix* m = new Matrix(*mainMatr);
        for (int i = 0; i < size; i++)
            m->set(i, n, equations[i].result);
        return m;
    }
 
    MTYPE* get_solutions() {
        //int past = 0;
        MTYPE* sols = (MTYPE*) malloc(sizeof(MTYPE) * size);
        Matrix* mm = get_main_matrix();
        MTYPE mmdet = mm->get_determinant();
        for (int i = 0; i < size; i++) {
            //cout << ++past << endl;
            Matrix* nth = get_nth_matrix(i, mm);
            MTYPE ndet = nth->get_determinant();
 
            sols[i] = ndet / mmdet;
            delete nth;
        }
        delete mm;
 
        return sols;
    }
 
    string to_string() {
        string str = "";
        for (int i = 0; i < size; i++) {
            LinearEquation eq = equations[i];
            for (int k = 0; k < size; k++) {
                ConstValue cv = eq.left_part[k];
                str += tstr(cv.value);
                str += cv.var;
                if (k != size - 1)
                    str += " + ";
            }
            str += " = ";
            str += tstr(eq.result);
            str += "\n";
        }
        return str;
    }
};
 
MTYPE sprnd() {
    return (rand() % 2 == 0 ? 1 : -1) * ((rand() % 90) / 10.0 + 1);
}
 
LinearEquationSystem generate_random_les(int hm) {
    LinearEquationSystem les(hm);
 
    double* vals = new double[hm];
    for (int i = 0; i < hm; i++)
        vals[i] = sprnd();
 
    for (int i = 0; i < hm; i++) {
        MTYPE curRes = 0;
        ConstValue* cvs = new ConstValue[hm];
 
        for (int k = 0; k < hm; k++) {
            char c = 'a' + k;
            MTYPE coeff = sprnd();
            ConstValue ccvs(c, coeff);
            cvs[k] = ccvs;
            curRes += vals[k] * coeff;
        }
 
        LinearEquation le(hm, curRes);
        le.left_part = cvs;
        les.equations[i] = le;
    }
    delete[] vals;
 
    return les;
}
 
int main() {
    srand(time(NULL));
 
    /*LinearEquationSystem les(3);
 
     LinearEquation f(3, 30);
 
     f.left_part[0] = *(new ConstValue('a', 2));
     f.left_part[1] = *(new ConstValue('b', 5));
     f.left_part[2] = *(new ConstValue('c', 4));
 
     LinearEquation s(3, 150);
     s.left_part[0] = *(new ConstValue('a', 1));
     s.left_part[1] = *(new ConstValue('b', 3));
     s.left_part[2] = *(new ConstValue('c', 2));
 
     LinearEquation t(3, 110);
     t.left_part[0] = *(new ConstValue('a', 2));
     t.left_part[1] = *(new ConstValue('b', 10));
     t.left_part[2] = *(new ConstValue('c', 9));
 
     LinearEquation larr[] = { f, s, t };
 
     les.equations = larr;
 
     for (int i = 0; i < 3; i++)
     cout << les.get_nth_solution(i) << endl;*/
    //cout << sprnd() << endl;
    for (;;) {
        lec = 0, led = 0, lesc = 0, lesd = 0, cvc = 0, cvd = 0, mc = 0, md = 0;
        cout << "===============" << endl;
        LinearEquationSystem les = generate_random_les(3);
        cout << les.to_string() << endl;
 
        MTYPE* sols = les.get_solutions();
        for (int k = 0; k < les.size; k++) {
            cout << sols[k] << " ";
        }
        cout << endl;
        free(sols);
        cout << "LE Constructor calls: " << lec << endl;
        cout << "LES Constructor calls: " << lesc << endl;
        cout << "CV Constructor calls: " << cvc << endl;
        cout << "Matrix Constructor calls: " << mc << endl;
 
        cout << "LE Destructor calls: " << led << endl;
        cout << "LES Destructor calls: " << lesd << endl;
        cout << "CV Destructor calls: " << cvd << endl;
        cout << "Matrix Destructor calls: " << md << endl;
    }
 
    return 0;
}

data = (double**) malloc(sizeof(MTYPE*) * size);