在类中超载运算符时返回错误

Question

当将矩阵乘以向量时，返回了一个方形矩阵，尽管它是在过载正文中构建的。我检查了“ =”运算符和复制构造函数，我是否缺少某些东西，还是问题是其他问题？ 将正方形矩阵乘以矩形矩阵（列）时，由于这个问题可能是什么？ 主：

#include <iostream>
#include "/home/qapfuc/Documents/Nizhny-Novgorod-State-University/Fourth LAB/vectorLib/MyMatrix.h"
#include "/home/qapfuc/Documents/Nizhny-Novgorod-State-University/Fourth LAB/vectorLib/MyVector.h"

int main(){
    MyVector<int> b{2,2};
    MyMatrix<int> y(2,2);
    MyMatrix<int> yy(2,2);
    std::cin>>yy;
    std::cin>>y;
    std::cout<<yy<<std::endl;
    yy=yy*y;
    std::cout<<yy<<std::endl;
}

mymatrix.h

#pragma once
#include "MyVector.h"

template <class ClassName>
class MyMatrix :public MyVector<ClassName>{
protected:
        ClassName **ArrayMatrix;
        int ArraySize_x = 3;
        int ArraySize_y = 3;
public:
        //Конструкторы
        MyMatrix() {
            ArrayMatrix = new ClassName*[ArraySize_x];
            for (int i = 0; i < ArraySize_x; i++) {
                ArrayMatrix[i] = new ClassName[ArraySize_y];
            }
            for (int i = 0; i < ArraySize_x; i++){
                for (int j = 0; j < ArraySize_y; j++){
                    ArrayMatrix[i][j]=0;
                }
            }
        }
        MyMatrix(int x,int y){
            ArraySize_x=x;
            ArraySize_y=y;
            ArrayMatrix = new ClassName*[ArraySize_x];
            for (int i = 0; i < ArraySize_x; i++) {
                ArrayMatrix[i] = new ClassName[ArraySize_y];
            }
            for (int i = 0; i < ArraySize_x; i++){
                for (int j = 0; j < ArraySize_y; j++){
                    ArrayMatrix[i][j]=0;
                }
            }
        }
        MyMatrix(const MyMatrix<ClassName> &other){
            ArraySize_x=other.ArraySize_x;
            ArraySize_y=other.ArraySize_y;
            ArrayMatrix = new  ClassName*[ArraySize_x];
            for (int i = 0; i < ArraySize_x; i++) {
                ArrayMatrix[i] = new ClassName[ArraySize_y];
            }
            for (int i = 0; i < ArraySize_x; i++){
                for (int j = 0; j < ArraySize_y; j++){
                    ArrayMatrix[i][j]=other.ArrayMatrix[i][j];
                }
            }
        }
        ~MyMatrix(){
            for (int i = 0; i < ArraySize_x; i++) {
                delete [] ArrayMatrix[i];
            }
            delete [] ArrayMatrix;
        }

        //Операторы
        auto operator[](const int index){
            return ArrayMatrix[index];
        };
        MyMatrix operator = (MyMatrix<ClassName> other) {
            if ((ArraySize_x == other.ArraySize_x) && (ArraySize_y == other.ArraySize_y)) {
                for (int i = 0; i < ArraySize_x; i++) {
                    for (int j = 0; j < ArraySize_y; j++) {
                        ArrayMatrix[i][j] = other.ArrayMatrix[i][j];
                    }
                }
                return *this;
            } else{
                MyMatrix<ClassName> temp(other.ArraySize_x,other.ArraySize_y);
                for (int i = 0; i < other.ArraySize_x; i++) {
                    for (int j = 0; j < other.ArraySize_y; j++) {
                        temp.ArrayMatrix[i][j] = other.ArrayMatrix[i][j];
                    }
                }
                return temp;
            }
        };
        MyMatrix operator+(MyMatrix<ClassName>& other){
            if ((ArraySize_x == other.ArraySize_x) && (ArraySize_y == other.ArraySize_y)) {
                MyMatrix<ClassName> temp(ArraySize_x, ArraySize_y);
                for (int i = 0; i < ArraySize_x; i++) {
                    for (int j = 0; j < ArraySize_y; j++) {
                        temp.ArrayMatrix[i][j] = ArrayMatrix[i][j] + other.ArrayMatrix[i][j];
                    }
                }
                return temp;
            }else{
                std::cout<<"The number of rows does not match the number of columns in the matrices. Check the matrices."<<std::endl;
                abort();
            }
        };
        MyMatrix operator-(MyMatrix<ClassName>& other){
            if ((ArraySize_x == other.ArraySize_x) && (ArraySize_y == other.ArraySize_y)) {
                MyMatrix<ClassName> temp(ArraySize_x, ArraySize_y);
                for (int i = 0; i < ArraySize_x; i++) {
                    for (int j = 0; j < ArraySize_y; j++) {
                        temp.ArrayMatrix[i][j] = ArrayMatrix[i][j] - other.ArrayMatrix[i][j];
                    }
                }
                return temp;
            }else{
                std::cout<<"The number of rows does not match the number of columns in the matrices. Check the matrices."<<std::endl;
                abort();
            }
        };
        MyMatrix operator*(MyMatrix<ClassName>& other){
            if(ArraySize_y==other.ArraySize_x) {
                MyMatrix<ClassName> temp(ArraySize_x, other.ArraySize_y);
                for (int i = 0; i < ArraySize_x; i++) {
                    for (int j = 0; j < other.ArraySize_x; j++) {
                        for (int k = 0; k < ArraySize_y; k++) {
                            temp.ArrayMatrix[i][j] += ArrayMatrix[i][k] * other.ArrayMatrix[k][j];
                        }
                    }
                }
                return temp;
            }
            else{
                std::cout<<"The number of rows does not match the number of columns in the matrices. Check the matrices."<<std::endl;
                abort();
            }
        };





        MyMatrix operator*(MyVector<ClassName>& other){
            if(ArraySize_y==other.GetSize()) {
                MyMatrix<ClassName> temp(other.GetSize(),1);
                for (int i = 0; i < temp.ArraySize_x; i++) {
                    for (int j = 0; j < 1; j++) {
                        for (int k = 0; k < other.GetSize(); k++) {
                            temp.ArrayMatrix[i][j] += ArrayMatrix[i][k] * other.GetArrayVector(k);
                        }
                    }
                }
                std::cout<<temp<<std::endl;
                return temp;
            }
            else{
                std::cout<<"The number of rows does not match the number of columns in the matrices. Check the matrices."<<std::endl;
                abort();
            }
        };





        friend std::ostream& operator<< (std::ostream& os, MyMatrix<ClassName> &Input){
            for( int i=0; i<Input.ArraySize_x;i++){
                for( int j=0; j<Input.ArraySize_y;j++) {
                    os << Input.ArrayMatrix[i][j]<<" ";
                }
                os<<std::endl;
            }
            return os;
        };
        friend std::istream& operator>>(std::istream &in, MyMatrix<ClassName>& Output){
            for( int i=0; i<Output.ArraySize_x;i++){
                for( int j=0; j<Output.ArraySize_y;j++) {
                    in >> Output.ArrayMatrix[i][j];
                }
            }
            return in;
        };

};
template <class ClassName>
bool operator==(MyMatrix<ClassName> &First,MyMatrix<ClassName> &Second){
    if((First.ArraySize_x!=Second.ArraySize_x) || (First.ArraySize_y!=Second.ArraySize_y)){
        return false;
    }
    for( int i=0;i<First.ArraySize_x;i++){
        for( int j=0;j<First.ArraySize_y;j++) {
            if (First.ArrayMatrix[i][j] != Second.ArrayMatrix[i][j]) {
                return false;
            }
        }
    }
    return true;
}
template <class ClassName>
bool operator!=(MyMatrix<ClassName> &First,MyMatrix<ClassName> &Second){
    return not(First==Second);
}

myVector.h

#pragma once
#include "MyMatrix.h"

template <class ClassName>
class MyVector{
protected:
        ClassName* ArrayVector;
        int ArraySize = 3;
public:
        ClassName GetArrayVector(int index){
            return ArrayVector[index];
        }
        int GetSize(){
            return ArraySize;
        }
        //Конструкторы
        MyVector(){
            ArrayVector = new ClassName[ArraySize];
            for( int i=0; i<ArraySize; i++){
                ArrayVector[i]=0;
            }
        }
        MyVector(int Size){
            ArraySize=Size;
            ArrayVector = new ClassName[ArraySize];
            for( int i=0; i<ArraySize; i++){
                ArrayVector[i]=0;
            }
        }
        MyVector(const std::initializer_list<ClassName> &list):MyVector(list.size()){
            int count = 0;
            for (auto &element : list)
            {
                ArrayVector[count] = element;
                ++count;
            }
        }
        MyVector(const MyVector<ClassName> &other){
            ArraySize=other.ArraySize;
            ArrayVector = new  ClassName[ArraySize];
            for( int i=0;i<ArraySize;i++){
                ArrayVector[i]=other.ArrayVector[i];
            }
        }
        ~MyVector(){
                delete [] ArrayVector;
        }

        //Операторы
        int& operator[](const int index){
            return ArrayVector[index];
        };
        MyVector operator=(MyVector<ClassName> other){
            if (ArraySize==other.ArraySize) {
                for (int i = 0; i < ArraySize; i++) {
                    ArrayVector[i] = other.ArrayVector[i];
                }
                return *this;
            } else {
                std::cout<<"The number of elements is not correct. Check the vector."<<std::endl;
                abort();
            }
        };
        MyVector operator+(MyVector<ClassName> other){
            if (ArraySize==other.ArraySize) {
                MyVector<ClassName> temp(ArraySize);
                for (int i = 0; i < ArraySize; i++) {
                    temp.ArrayVector[i] = ArrayVector[i] + other.ArrayVector[i];
                }
                return temp;
            }else{
                std::cout<<"The number of elements is not correct. Check the vector."<<std::endl;
                abort();
            }
        };
        MyVector operator-(MyVector<ClassName> other){
            if (ArraySize==other.ArraySize) {
                MyVector<ClassName> temp(ArraySize);
                for (int i = 0; i < ArraySize; i++) {
                    temp.ArrayVector[i] = ArrayVector[i] - other.ArrayVector[i];
                }
                return temp;
            } else {
                std::cout<<"The number of elements is not correct. Check the vector."<<std::endl;
                abort();
            }
        };
        MyVector operator*(MyVector<ClassName> other){
            if (ArraySize==other.ArraySize) {
                MyVector<ClassName> temp(ArraySize);
                for (int i = 0; i < ArraySize; i++) {
                    temp.ArrayVector[i] = ArrayVector[i] * other.ArrayVector[i];
                }
                return temp;
            } else {
                std::cout<<"The number of elements is not correct. Check the vector."<<std::endl;
                abort();
            }
        };
        MyVector operator/(MyVector<ClassName> other){
            if (ArraySize==other.ArraySize) {
                MyVector<ClassName> temp(ArraySize);
                for (int i = 0; i < ArraySize; i++) {
                    temp.ArrayVector[i] = (ArrayVector[i])/(other.ArrayVector[i]);
                }
                return temp;
            } else {
                std::cout<<"The number of elements is not correct. Check the vector."<<std::endl;
                abort();
            }
        };

        friend std::ostream& operator<< (std::ostream& os, MyVector<ClassName> &Input){
            for( int i=0; i<Input.ArraySize;i++){
                os<<Input.ArrayVector[i]<<std::endl;
            }
            return os;
        };

        friend std::istream& operator>>(std::istream &in, MyVector<ClassName>& Output){
            for( int i=0; i<Output.ArraySize;i++){
                in>>Output.ArrayVector[i];
            }
            return in;
        };
};
template <class ClassName>
bool operator==(MyVector<ClassName> &First,MyVector<ClassName> &Second){
    if(First.ArraySize!=Second.ArraySize){
        return false;
    }
    for( int i=0;i<First.ArraySize;i++){
        if(First.ArrayVector[i]!=Second.ArrayVector[i]){
            return false;
        }
    }
    return true;
}
template <class ClassName>
bool operator!=(MyVector<ClassName> &First,MyVector<ClassName> &Second){
    return not(First==Second);
}