Как должна выглядеть реализация перегрузки умножения двух верхнетреугольных матриц?

const int MAX_VECTOR_SIZE = 100000000;
const int MAX_MATRIX_SIZE = 10000;
 
template <class ValType>
class TVector
{
protected:
    ValType *pVector;
    int Size;       // размер вектора
    int StartIndex; // индекс первого элемента вектора
public:
    TVector(int s = 10, int si = 0);
    TVector(const TVector &v);                // конструктор копирования
    ~TVector();
    int GetSize() { return Size; } // размер вектора
    int GetStartIndex() { return StartIndex; } // индекс первого элемента
    ValType& operator[](int pos);             // доступ
    bool operator==(const TVector &v) const;  // сравнение
    bool operator!=(const TVector &v) const;  // сравнение
    TVector& operator=(const TVector & v);     // присваивание
 
                                               // скалярные операции
    TVector  operator+(const ValType &val);   // прибавить скаляр
    TVector  operator-(const ValType &val);   // вычесть скаляр
    TVector  operator*(const ValType &val);   // умножить на скаляр
 
                                              // векторные операции
    TVector  operator+(const TVector &v);     // сложение
    TVector  operator-(const TVector &v);     // вычитание
    ValType  operator*(const TVector &v);     // скалярное произведение
 
                                              // ввод-вывод
    friend istream& operator>>(istream &in, TVector &v)
    {
        for (int i = 0; i < v.Size; i++)
            in >> v.pVector[i];
        return in;
    }
    friend ostream& operator<<(ostream &out, const TVector &v)
    {
        for (int i = 0; i < v.Size; i++)
            out << v.pVector[i] << ' ';
        return out;
    }
};
 
template <class ValType> 
TVector<ValType> TVector<ValType>::operator*(const ValType &val)
{
    TVector<ValType> result(Size, StartIndex);
 
    for (int i = 0; i < Size; i++)
        result.pVector[i] = pVector[i] * val;
 
    return result;
} 
 
template <class ValType> 
ValType TVector<ValType>::operator*(const TVector<ValType> &v)
{
    try
    {
        if (Size != v.Size) throw 1;
        if (StartIndex != v.StartIndex) throw 2;
 
        ValType result = 0;
 
        for (int i = 0; i < Size; i++)
            result = result + (pVector[i] * v.pVector[i]);
 
        return result;
    }
 
    catch (int error)
    {
        switch (error)
        {
        case 1: cout << "Error! Size of vactors don't equal." << endl; break;
        case 2: cout << "Error! Start indexs don't equal." << endl;
        }
        throw 1;
    }
} 
 
template <class ValType>
class TMatrix : public TVector<TVector<ValType> >
{
public:
    TMatrix(int s = 10);
    TMatrix(const TMatrix &mt);                    // копирование
    TMatrix(const TVector<TVector<ValType> > &mt); // преобразование типа
    bool operator==(const TMatrix &mt) const;      // сравнение
    bool operator!=(const TMatrix &mt) const;      // сравнение
    TMatrix& operator= (const TMatrix &mt);        // присваивание
    TMatrix  operator+ (const TMatrix &mt);        // сложение
    TMatrix  operator- (const TMatrix &mt);        // вычитание   
    TMatrix  operator* (const TMatrix &mt);        //умножение