How to make this C++ program run? It is the answer I got from answers but somehow it can't run. Matrix.h #ifndef MATRIX_H

[answerhappygod]

How to make this C++ program run?
It is the answer I got from answers but somehow it can't run.

Matrix.h
#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <vector>
#include <exception>
#include <stdexcept>

using namespace std;


class InvalidException : public std::exception
{
public:
InvalidException(std::string str):m_Str(str)
{
}
const char* what() const throw(){ return m_Str.c_str();}
private:
std::string m_Str;
};

class Matrix
{
public:


Matrix(size_t r = 0,size_t c = 0 ,int d = 0);
Matrix(size_t r, size_t c,vector<int> vec);

Matrix& operator+=(const Matrix &m);
Matrix& operator-=(const Matrix &m);
Matrix& operator*=(const Matrix &m);

Matrix& operator+=(int d);
Matrix& operator-=(int d);
Matrix& operator*=(int d);

//Output
void print(ostream &sout) const ;
size_t ncols() const {return cols;}
size_t nrows() const {return rows;}

private:
size_t rows;
size_t cols;
std::vector<std::vector<int>> element;
};

Matrix operator+(const Matrix &l, const Matrix &r);
Matrix operator-(const Matrix &l, const Matrix &r);

Matrix operator*(const Matrix &l, const Matrix &r);
Matrix operator*(int d, const Matrix &r);
Matrix operator*(const Matrix &l,int d);

Matrix operator+(const Matrix &l,int d);
Matrix operator+(int d, const Matrix &r);

Matrix operator-(const Matrix &l,int d);
Matrix operator-(int d, const Matrix &r);

ostream& operator<<(ostream &out,const Matrix& m);


#endif

Matrix.cpp


#include <iostream>
#include <vector>
#include <stdexcept>
#include "Matrix.h"

Matrix::Matrix(size_t r, size_t c, int d):rows(r),cols(c),element(r,std::vector<int>(static_cast<int>(c),0))
{
for(size_t i = 0 ; i < r; i++)
{
for(size_t j = 0 ; j < cols; j++)
{
element[j] = d;
}
}
}
Matrix::Matrix(size_t r, size_t c, vector<int> vec):rows(r),cols(c),element(r,std::vector<int>(static_cast<int>(c),0))
{
for(size_t i = 0 ; i < vec.size(); i++)
{
int row = i/cols;
int col = i%cols;
element[row][col] = vec;
}
}

Matrix& Matrix::operator+=(const Matrix &m)
{
if(rows != m.rows || cols != m.cols)
{
throw InvalidException("One of matrix size is not valid");
}
for(size_t i = 0 ; i < rows ; i++)
{
for(size_t j = 0 ; j < cols; j++)
{
element[j] += m.element[j];
}
}
return *this;

}
Matrix& Matrix::operator-=(const Matrix &m)
{
if(rows != m.rows || cols != m.cols)
{
throw InvalidException("One of matrix size is not valid");
}

for(size_t i = 0 ; i < rows ; i++)
{
for(size_t j = 0 ; j < cols; j++)
{
element[j] -= m.element[j];
}
}
return *this;
}
Matrix& Matrix::operator*=(const Matrix &m)
{
if (cols != m.rows)
{
throw InvalidException("One of matrix size is not valid");
}
if(cols == m.rows)
{
vector<int> vecTemp(rows*m.cols,0);

for(size_t i = 0 ; i < rows; i++)
{
for(size_t j = 0 ; j < m.cols; j++)
{
for(size_t k = 0 ; k < cols; k++)
{
vecTemp[i*m.cols + j] += element [k] * m.element[k][j];
}
}
}

for(size_t i = 0; i < rows*cols; i++)
{
int row = i/cols;
int col = i%cols;
element[row][col] = vecTemp;
}
}
return *this;
}

Matrix& Matrix::operator*=(int d)
{
for(size_t i = 0 ; i < rows ; i++)
{
for(size_t j = 0 ; j < cols ; j++)
{
element[j] *= d;
}
}
return *this;
}
Matrix& Matrix::operator+=(int d)
{
for(size_t i = 0 ; i < rows ; i++)
{
for(size_t j = 0 ; j < cols; j++)
{
element[j] +=d;
}
}
return *this;
}
Matrix& Matrix::operator-=(int d)
{
for(size_t i = 0 ; i < rows ; i++)
{
for(size_t j = 0 ; j < cols; j++)
{
element[i][j] -=d;
}
}
return *this;
}
void Matrix::print(ostream &sout) const
{
for(size_t i = 0 ; i <rows ; i++)
{
for(size_t j = 0 ; j < cols; j++)
{
std::cout<<element[i][j]<<" ";
}
std::cout<<std::endl;
}
}
Matrix operator+(const Matrix &l, const Matrix &r)
{
Matrix m(l);
m += r;
return m;
}
Matrix operator-(const Matrix &l, const Matrix &r)
{
Matrix m(l);
m -= r;
return m;
}
Matrix operator*(const Matrix &l, const Matrix &r)
{
Matrix m(l);
m *= r;
return m;
}
Matrix operator*(int d, const Matrix &r)
{
Matrix m(r);
m *= d;
return m;
}
Matrix operator*(const Matrix &l,int d)
{
Matrix m(l);
m *= d;
return m;
}

Matrix operator+(const Matrix &l,int d)
{
Matrix m(l);
m+= d;
return m;
}
Matrix operator+(int d, const Matrix &r)
{
Matrix m(r);
m+= d;
return m;
}

Matrix operator-(const Matrix &l,int d)
{
Matrix m(l);
m-= d;
return m;
}
Matrix operator-(int d, const Matrix &r)
{
Matrix m(r);
m-= d;
return m;
}

ostream& operator<<(ostream &out,const Matrix& m)
{
m.print(out);
return out;
}

Main.cpp
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>

#include "Matrix.h"




int main()
{

std::vector<int> vecA{1,1,1,1};

Matrix a(2,2,vecA);
std::cout<<"Matrix A\n";
std::cout<<a;
std::cout<<std::endl;

Matrix b(2,2,3);
std::cout<<"Matrix B\n";
b.print(cout);
std::cout<<std::endl;

std::cout<<"Matrix A + 1 \n";
a += 1;
std::cout<<"Matrix \n";
std::cout<<a<<std::endl;

std::cout<<"Matrix A * 2 \n";
a *= 2;
std::cout<<"Matrix C\n";
std::cout<<a<<std::endl;

std::cout<<"Matrix A - 1 \n";
a -= 1;
std::cout<<"Matrix \n";
std::cout<<a<<std::endl;



std::cout<<"Matrix A + Matrix B \n";
Matrix d = a + b ;
std::cout<<"Matrix d\n";
std::cout<<d<<std::endl;

std::cout<<"Matrix A - Matrix B\n";
d = a - b ;
std::cout<<"Matrix d\n";
std::cout<<d<<std::endl;

std::cout<<"Matrix A * Matrix B\n";
d = a * b ;
std::cout<<"Matrix d\n";
std::cout<<d<<std::endl;

std::vector<int> vecC{3,3,3,3,3,3,3,3,3};
Matrix c(3,3,vecC);

try
{
std::cout<<"Matrix A + Matrix C\n";
Matrix f = a + c;
}
catch(const InvalidException &exp)
{
std::cout<<exp.what()<<std::endl;
}

try
{
std::cout<<"Matrix A - Matrix C\n";
Matrix f = a - c;
}
catch(const InvalidException &exp)
{
std::cout<<exp.what()<<std::endl;
}

try
{
std::cout<<"Matrix A * Matrix C\n";
Matrix f = a * c;
}
catch(const InvalidException &exp)
{
std::cout<<exp.what()<<std::endl;
}



}

Compilation g++ -g -Wall -Werror -o Matrix Matrix.cpp Main.cpp
Sample Output
Matrix A
1 1
1 1

Matrix B
3 3
3 3

Matrix A + 1
Matrix
2 2
2 2

Matrix A * 2
Matrix C
4 4
4 4

Matrix A - 1
Matrix
3 3
3 3

Matrix A + Matrix B
Matrix d
6 6
6 6

Matrix A - Matrix B
Matrix d
0 0
0 0

Matrix A * Matrix B
Matrix d
18 18
18 18

Matrix A + Matrix C
One of matrix size is not valid
Matrix A - Matrix C
One of matrix size is not valid
Matrix A * Matrix C
One of matrix size is not valid