Не работает перегрузка сложения в классе матриц

#include <iostream>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <conio.h> 
#include <stdio.h>
 
using namespace std;
 
int kol_row;
 
class Vector
{
    double* vec;
    int size;
public:
 
    //Constructor default
    Vector(int sizeVec)
    {
        size = sizeVec;
        this->vec = new double[size]; //было sizeVec
 
        for (int i = 0; i < size; i++)  //было sizeVec
        {
            vec[i] = i + 1;
        }
    }
 
    // Consructor of coping
    Vector(const Vector& obj)
    {
        size = obj.size;
        vec = new double[obj.size];
        for (int i = 0; i < obj.size; i++)
        {
            vec[i] = obj.vec[i];
        }
    }
 
    //Consructor NULL
    Vector()
    {
        size = 0;
        vec = NULL;
    }
 
    //Destructor
    ~Vector()
    {
        delete[] vec;
    }
 
    //Operator =
    Vector& operator =(Vector const& ob)
    {
        if (this == &ob)
            return *this;
        delete[] vec;
 
        vec = new double[ob.size];
        size = ob.size;
        for (int i = 0; i < size; i++)
        {
            vec[i] = ob.vec[i];
        }
        return *this;
    }
 
    //Operator +
    Vector operator +(const Vector const& other)
    {
        int size = this->size > other.size ? this->size : other.size;
 
        Vector temp(size);
        for (int i = 0; i < size; i++)
            temp.vec[i] = (i < this->size ? vec[i] : 0) + (i < other.size ? other.vec[i] : 0);
        return temp;
    }
 
    //Unary operato -
    Vector& operator -(const int num)
    {
        for (int i = 0; i < size; i++)
            vec[i] -= num;
        return *this;
    }
    Vector& operator -()
    {
        for (int i = 0; i < size; i++)
            vec[i] = -vec[i];
        return *this;
    }
    //Binary operator -
    Vector operator -(const Vector const& other)
    {
        int size = this->size > other.size ? this->size : other.size;
 
        Vector temp(size);
        for (int i = 0; i < size; i++)
            temp.vec[i] = (i < this->size ? vec[i] : 0) - (i < other.size ? other.vec[i] : 0);
        return temp;
    }
 
    //operator * (2 vectors)
    Vector operator *(const Vector const& other)
    {
        int size = this->size > other.size ? this->size : other.size;
 
        Vector temp(size);
        for (int i = 0; i < size; i++)
            temp.vec[i] = (i < this->size ? vec[i] : 1) * (i < other.size ? other.vec[i] : 1);
        return temp;
    }
 
    //operator * (vector and number)
    Vector& operator *(const int num)
    {
        for (int i = 0; i < size; i++)
            vec[i] *= num;
        return *this;
    }
 
 
    // operator []
    Vector operator[](int index)
    {
        return vec[index];
    }
 
    // operator * (number and vector)
    friend Vector operator *(int num, const Vector &vec)
    {
        Vector temp(vec.size);
        for (int i = 0; i < vec.size; ++i)
            temp.vec[i] = num * vec.vec[i];
        return temp;
    }
 
    void print()
    {
        for (int i = 0; i < size; ++i)
            cout << vec[i] << " ";
        cout << endl;
    }
 
    //возвращает размер вектора
    int getSize()
    {
        return size;
    }
 
    //оператор вывода в поток
    friend ostream& operator <<(ostream& out,  Vector const& a)
    {
        for (int i = 0; i < a.size; i++)
            out << a.vec[i] << ' ';
        //out << endl;
        return out;
    }
    void clean(int n, float t = 1 )
    {
        if (vec != NULL)
            delete vec;
        size = n;
        vec = new double[size];
        for (int i = 0; i < size; i++)
            vec[i] = t;
    }
};
 
 
 
class matrix
{
public:
    Vector* vector;
    int rows;
    int columns;
 
 
 
    matrix(const matrix &ob)
    {
        rows = ob.rows;
        columns = ob.columns;
        vector = new Vector[rows];
        for (int i = 0; i < rows; i++)
        {
            vector[i].clean(columns);
            for (int j = 0; j < columns; j++)
                vector[i][j] = ob.vector[i][j];
        }
    }
 
 
    matrix(int n, int m, float value = 0)
    {
        rows = n;
        columns = m;
        vector = new Vector [rows];
        for (int i = 0; i < rows; i++)
        {
            vector[i].clean(columns, value);
        }
    }
 
    matrix()
    {
        rows = 4;
        columns = 4;
        vector = new Vector[rows];
        for (int i = 0; i < rows; i++)
        {
            vector[i].clean(columns, 5);
            
        }
    }
    
    
    ~matrix()
    {
    
          delete[] vector;
        
    }
    matrix& operator =(matrix& mat)
    {
        if (vector != NULL)
        {
            delete[] vector;
            rows = 0;
            columns = 0;
        }
        rows = mat.rows;
        columns = mat.columns;
        vector = new Vector[rows];
        for (int i = 0; i < rows; i++)
        {
            vector[i].clean(columns);
            for (int j = 0; j < columns; j++)
                vector[i][j] = mat.vector[i][j];
        }
        return *this;
    }
    Vector& operator [](int i)
    {
        return vector[i];
    }
 
    matrix operator +(matrix &matr2) 
    {
        if (rows < matr2.rows)
            rows = matr2.rows;
        if (columns < matr2.columns)
            columns = matr2.columns;
        //rows = matr2.rows;
        //columns = matr2.columns;
        matrix result(rows, columns);
    //  for (int i = 0; i < rows; i++)
        //  result[i] = vector[i];
        for (int i = 0; i < rows; i++)
            result[i] = matr2[i] + vector[i];
        return result;
        
        
    }
    //operator +
    /*matrix operator +(matrix matr2)
    {
        if (rows == matr2.rows && columns == matr2.columns)
        {
            matrix result(rows, columns);
            for (int i = 0; i < matr2.rows; i++)
                for (int j = 0; j < matr2.columns; j++)
                    result.matr[i][j] = matr[i][j] + matr2(i, j);
            return result;
        }
        else
        {
            cout << "Error" << endl;
            _getch();
            exit(1);
            
        }
    }*/
 
    friend ostream& operator<<(ostream& out, const matrix m)
    {
        for (int i = 0; i < m.rows; i++)
        {
            for (int j = 0; j < m.columns; j++)
                out << m.vector[i][j] << "  ";
            out << endl;
        }
        return out;
    }
    matrix transpose()
    {
        matrix tran(columns, rows);
        for (int i = 0; i < tran.rows; i++) 
        {
            for (int j = 0; j < tran.columns; j++)
                tran.vector[i][j] = vector[j][i];
        }
        return tran;
    }
    int getRows()
    {
        return rows;
    }
 
    int getColumns()
    {
        return columns;
    }
};
 
 
int main()
{
 
    matrix A(3, 3);
    cout << "A:" << endl<<A;
    matrix B(A);
    cout <<"B"<<endl<< B;
    matrix C (3, 3);
    cout << "C: " << endl << C;
    cout <<"C + A:"<<endl<< (C + A);
 
}

    matrix operator +(const matrix &matr2)const 
    {
        int r, c;
        if (rows < matr2.rows)
            r = matr2.rows;
        else r = rows;
        if (columns < matr2.columns)
            c = matr2.columns;
        else c = columns;
        matrix result(r, c);
        for (int i = 0; i < r; i++)
            result[i] = matr2[i] + vector[i];
        return result;
    }

    matrix operator +(const matrix &matr2) const
    {
        matrix result(rows, columns);
        for (int i = 0; i < rows; i++)
            result[i] = matr2[i] + vector[i];
        return result;
        
        
    }