Matrices

#include <vector>
#include <iostream>

using namespace std;

class matrix {
public:
    matrix();
    matrix(const matrix &orig);

    int first_dimension();
    int second_dimension();

    bool can_multiply(matrix &cpy);
    bool can_add(matrix &cpy);
    bool can_subtract(matrix &cpy);

    void multiply(matrix &cpy);
    void multiply_by_scalar(const double c);
    void add(matrix &cpy);
    void subtract(matrix &cpy);
    // debug
    void input();
    void output();
private:
    vector<vector<double> > m;
};

void matrix::input() {
    int x, y;
    cin >> x >> y;
    m.resize(x, vector<double>(y));
    for(int i = 0; i < x; ++i) {
        for(int j = 0; j < y; ++j) {
            cin >> m[i][j];
        }
    }
}

void matrix::output() {
    for(int i = 0; i < first_dimension(); ++i) {
        for(int j = 0; j < second_dimension(); ++j) {
            cout << m[i][j] << ' ';
        }
        cout << endl;
    }
}

matrix::matrix() {}

matrix::matrix(const matrix &orig) {
    this->m = orig.m;
}

int matrix::first_dimension() {
    return m.size();
}

int matrix::second_dimension() {
    return m[0].size();
}

bool matrix::can_multiply(matrix &cpy) {
    if(m[0].size() == cpy.first_dimension()) {
        return true;
    }
    return false;
}

bool matrix::can_add(matrix &cpy) {
    if(m.size() == cpy.first_dimension()
       && m[0].size() == cpy.second_dimension()) {
        return true;
    }
    return false;
}

bool matrix::can_subtract(matrix &cpy) {
    if(m.size() == cpy.first_dimension()
       && m[0].size() == cpy.second_dimension()) {
        return true;
    }
    return false;
}

void matrix::multiply_by_scalar(const double c) {
    for(int i = 0; i < m.size(); ++i) {
        for(int j = 0; j < m[i].size(); ++j) {
            m[i][j] *= c;
        }
    }
}

void matrix::add(matrix &cpy) {
    if(m.size() != cpy.first_dimension() || m[0].size() != cpy.second_dimension()) {
        cerr << "Entfin can happen C:";
        return;
    }
    for(int i = 0; i < m.size(); ++i) {
        for(int j = 0; j < m[i].size(); ++j) {
            m[i][j] += cpy.m[i][j];
        }
    }
}

void matrix::subtract(matrix &cpy) {
    if(m.size() != cpy.first_dimension() || m[0].size() != cpy.second_dimension()) {
        cerr << "Entfin can happen C:";
        return;
    }
    for(int i = 0; i < m.size(); ++i) {
        for(int j = 0; j < m[i].size(); ++j) {
            m[i][j] -= cpy.m[i][j];
        }
    }
}

void matrix::multiply(matrix &cpy) {
    if(!this->can_multiply(cpy)) {
        cerr << "Entfin can happen C:";
        return;
    }
    vector<vector<double> > newm(m.size(), vector<double>(cpy.m[0].size()));
    for(int i = 0; i < m.size(); ++i) {
        for(int j = 0; j < cpy.m[0].size(); ++j) {
            for(int k = 0; k < m[i].size(); ++k) {
                newm[i][j] += m[i][k] * cpy.m[k][j];
            }
        }
    }
    m = newm;
}

int main() {
    // usage example
    matrix a;
    matrix e;
    a.input();
    e.input();
    a.subtract(e);
    a.output();
}