Передать массив объектов класса Matrix в функцию

#include "stdafx.h"
 
#include <vector>
#include <iostream>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <cmath>
#include <Windows.h>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <string>
#include <stdexcept>
 
#ifndef _MATRIX_H_
#define _MATRIX_H_
namespace MatrSpace
{
    //Контейнерный класс матрицы
    template<class T> // создаем шаблон класс
    class AbstractMatr // создаем класс 
    {
    public:
        AbstractMatr() {} // Конструктор по умолчанию
        AbstractMatr(size_t n, size_t m);
        AbstractMatr(const AbstractMatr&Ob):Matrix(Ob.Matrix) {} // Конструктор копирования
        virtual ~AbstractMatr() {} 
        void SetSize(size_t n, size_t m);
        inline const size_t GetRow() const {return Matrix.size();}
        inline const size_t GetCol() const {return Matrix[0].size();}
        void swap(AbstractMatr&);
    protected:
        std::vector<std::vector<T> > Matrix;
    };
 
    //открытие математических функций матрицы AbstractMatr
    template<class T> создаем шаблон класс
    class MathMatr:public AbstractMatr<T> // создаем класс
    {
    public:
        MathMatr():AbstractMatr() {}
        MathMatr(size_t n, size_t m):AbstractMatr<T>(n, m) {}
        MathMatr(const AbstractMatr<T>& Ob):AbstractMatr<T>(Ob) {} // Конструктор копирования
        virtual ~MathMatr() {}
        float norma();  //норма матрицы
        const MathMatr<T>& operator =(const MathMatr&); // Перегрузка =
        const MathMatr<T>& operator +=(const MathMatr&);
        const MathMatr<T> operator +(const MathMatr&) const; // Сложение матриц
        const MathMatr<T>& operator -=(const MathMatr&);
        const MathMatr<T> operator -(const MathMatr&) const; // Вычитание матриц
        const MathMatr<T>& operator *=(const MathMatr&);
        const MathMatr<T> operator *(const MathMatr&) const; // Перемножение матриц
        virtual void input(std::istream&) {}
        virtual void output(std::ostream&) const {}
        template<class T2>
        friend std::ostream& operator <<(std::ostream&, const MathMatr<T2>& Ob); // Перегрузка оператора << для вывода матрицы
        template<class T2>
        friend std::istream& operator >>(std::istream&, MathMatr<T2>& Ob);  // Перегрузка оператора >> для ввода матрицы
        void random_fill();
    };
 
    //вывод ввод класса IOMatr из класса MathMatr
    template<class T>
    class IOMatr:public MathMatr<T>
    {
    public:
        IOMatr():MathMatr<T>() {}
        IOMatr(size_t n, size_t m):MathMatr(n, m) {}
        IOMatr(const AbstractMatr<T>& Ob):MathMatr(Ob) {}
        virtual ~IOMatr() {}
        virtual void input(std::istream&)=0;
        virtual void output(std::ostream&) const=0;
    };
 
    //вывод ввод класса IOMatr из класса MathMatr
    template<class T>
    class ConsoleMatr:public IOMatr<T>
    {
    public:
        ConsoleMatr():IOMatr<T>() {}
        ConsoleMatr(size_t n, size_t m):IOMatr(n, m) {}
        ConsoleMatr(const AbstractMatr<T>& Ob):IOMatr(Ob) {} // Конструктор копирования
        virtual ~ConsoleMatr() {}
        float norma();   // Норма матрицы 
        const ConsoleMatr<T>& operator =(const ConsoleMatr&); // Перегрузка =
        const ConsoleMatr<T>& operator +=(const ConsoleMatr&);
        const ConsoleMatr<T> operator +(const ConsoleMatr&) const; // Сложение матриц
        const ConsoleMatr<T>& operator -=(const ConsoleMatr&);
        const ConsoleMatr<T> operator -(const ConsoleMatr&) const; // Вычитание матриц
        const ConsoleMatr<T>& operator *=(const ConsoleMatr&);
        const ConsoleMatr<T> operator *(const ConsoleMatr&) const; // Перемножение матриц
        virtual void input(std::istream&);
        virtual void output(std::ostream&) const;
    };
    
    //AbstractMatr функции класса
    template<class T>
    AbstractMatr<T>::AbstractMatr(size_t n, size_t m) // Конструктор копирования
    {
        Matrix.resize(n);
        for(int i=0; i!=GetRow(); ++i)
        {
            Matrix[i].resize(m);
        }
    }
 
    template<class T>
    void AbstractMatr<T>::SetSize(size_t n, size_t m)  
    {
        if(GetRow()!=0&&GetCol()!=0)
            Matrix.clear();
        Matrix.resize(n);
        for(int i=0; i!=GetRow(); ++i)
        {
            Matrix[i].resize(m);
        }
    }
 
    template<class T>
    void AbstractMatr<T>::swap(AbstractMatr<T>& Ob)
    {
        Matrix.swap(Ob.Matrix);
    }
    
    //MathMatr функции класса
    template<class T>
    const MathMatr<T>& MathMatr<T>::operator =(const MathMatr<T>& Ob)
    {
        MathMatr<T> Temp(Ob);
        Temp.swap(*this);
        return *this;
    }
 //Сложение
    template<class T>
    const MathMatr<T>& MathMatr<T>::operator +=(const MathMatr<T>& Ob)
    {
        if(GetRow()!=Ob.GetRow()&&GetCol()!=Ob.GetCol())
            throw std::invalid_argument("Size of two matrix for sum must be equal!");
        for(int i=0; i!=Ob.GetRow(); ++i)
        {
           for(int j=0; j!=Ob.GetCol(); ++j)
           {
              Matrix[i][j]+=Ob.Matrix[i][j];
           }
        }
        return *this;
    }
 
    template<class T>
    const MathMatr<T> MathMatr<T>::operator +(const MathMatr<T>& Ob) const
    {
        MathMatr<T> Temp(*this);
        Temp+=Ob;
        return Temp;
    }
    //Вычитание
    template<class T>
    const MathMatr<T>& MathMatr<T>::operator -=(const MathMatr<T>& Ob)
    {
        if(GetRow()!=Ob.GetRow()&&GetCol()!=Ob.GetCol())
            throw std::invalid_argument("Size of two matrix for sum must be equal!");
        for(int i=0; i!=Ob.GetRow(); ++i)
        {
           for(int j=0; j!=Ob.GetCol(); ++j)
           {
              Matrix[i][j]-=Ob.Matrix[i][j];
           }
        }
        return *this;
    }
 
    template<class T>
    const MathMatr<T> MathMatr<T>::operator -(const MathMatr<T>& Ob) const
    {
        MathMatr<T> Temp(*this);
        Temp-=Ob;
        return Temp;
    }
 //Умножение
    template<class T>
    const MathMatr<T>& MathMatr<T>::operator *=(const MathMatr<T>& Ob)
    {
        if(GetCol()!=Ob.GetRow())
            throw std::invalid_argument("Num of 1-st matrix cols must be equal to num of 2-nd matrix rows");
        MathMatr Temp(GetRow(), Ob.GetCol());
        for(int i=0; i!=Temp.GetRow(); ++i)
        {
           for(int j=0; j!=Temp.GetCol(); ++j)
           {
              Temp.Matrix[i][j]=0;
              for(int k=0; k!=GetCol(); ++k)
              {
                 Temp.Matrix[i][j]+=Matrix[i][k]*Ob.Matrix[k][j];
              }
            }
        }
        *this=Temp;
        return *this;
    }
 
    template<class T>
    const MathMatr<T> MathMatr<T>::operator *(const MathMatr<T>& Ob) const
    {
        MathMatr<T> Temp(*this);
        Temp*=Ob;
        return Temp;
    }
 
    template<class T>
    void MathMatr<T>::random_fill()
    {
       for(int i=0; i!=GetRow(); ++i)
       {
          for(int j=0; j!=GetCol(); ++j)
          {
             Matrix[i][j]=1+rand()%50;
          }
       }
    }
 
    template<class T>
    std::ostream& operator <<(std::ostream& os, const MathMatr<T>& Ob)
    {
       Ob.output(os);
       return os;
    }
 
    template<class T>
    std::istream& operator >>(std::istream& is, MathMatr<T>& Ob)
    {
       Ob.input(is);
       return is;
    }
    
    //ConsoleMatr функции класса
    template<class T>
    void ConsoleMatr<T>::input(std::istream& is)
    {
       for(int i=0; i!=GetRow(); ++i)
       {
          for(int j=0; j!=GetCol(); ++j)
          {
              std::cout<<"Enter Matrix ["<<i+1<<"]["<<j+1<<"]: ";
              is>>Matrix[i][j];
          }
       }
    }
 
    template<class T>
    void ConsoleMatr<T>::output(std::ostream& os) const
    {
       for(int i=0; i!=GetRow(); ++i)
       {
          for(int j=0; j!=GetCol(); ++j)
          {
              os<<std::setw(5)<<Matrix[i][j]<<' ';
          }
          std::cout<<std::endl;
       }
    }
 
    template<class T>
    const ConsoleMatr<T>& ConsoleMatr<T>::operator =(const ConsoleMatr<T>& Ob)
    {
        ConsoleMatr Temp(Ob);
        Temp.swap(*this);
        return *this;
    }
 //сложение
    template<class T>
    const ConsoleMatr<T>& ConsoleMatr<T>::operator +=(const ConsoleMatr<T>& Ob)
    {
        if(GetRow()!=Ob.GetRow()&&GetCol()!=Ob.GetCol())
           throw std::invalid_argument("Size of two matrix for sum must be equal!");
        for(int i=0; i!=Ob.GetRow(); ++i)
        {
           for(int j=0; j!=Ob.GetCol(); ++j)
           {
              Matrix[i][j]+=Ob.Matrix[i][j];
           }
        }
        return *this;
    }
 
    template<class T>
    const ConsoleMatr<T> ConsoleMatr<T>::operator +(const ConsoleMatr<T>& Ob) const
    {
        ConsoleMatr<T> Temp(*this);
        Temp+=Ob;
        return Temp;
    }
    //вычитание
      template<class T>
    const ConsoleMatr<T>& ConsoleMatr<T>::operator -=(const ConsoleMatr<T>& Ob)
    {
        if(GetRow()!=Ob.GetRow()&&GetCol()!=Ob.GetCol())
           throw std::invalid_argument("Size of two matrix for vichitanie must be equal!");
        for(int i=0; i!=Ob.GetRow(); ++i)
        {
           for(int j=0; j!=Ob.GetCol(); ++j)
           {
              Matrix[i][j]-=Ob.Matrix[i][j];
           }
        }
        return *this;
    }
 
    template<class T>
    const ConsoleMatr<T> ConsoleMatr<T>::operator -(const ConsoleMatr<T>& Ob) const
    {
        ConsoleMatr<T> Temp(*this);
        Temp-=Ob;
        return Temp;
    }
 //умножение
    template<class T>
    const ConsoleMatr<T>& ConsoleMatr<T>::operator *=(const ConsoleMatr<T>& Ob)
    {
        if(GetCol()!=Ob.GetRow())
            throw std::invalid_argument("Num of 1-st matrix cols must be equal to num of 2-nd matrix rows");
        ConsoleMatr Temp(GetRow(), Ob.GetCol());
        for(int i=0; i!=Temp.GetRow(); ++i)
        {
           for(int j=0; j!=Temp.GetCol(); ++j)
           {
              for(int k=0; k!=GetCol(); ++k)
              {
                 Temp.Matrix[i][j]+=Matrix[i][k]*Ob.Matrix[k][j];
              }
            }
        }
        *this=Temp;
        return *this;
    }
 
    template<class T>
    const ConsoleMatr<T> ConsoleMatr<T>::operator *(const ConsoleMatr<T>& Ob) const
    {
        ConsoleMatr<T> Temp(*this);
        Temp*=Ob;
        return Temp;
    }
}
#endif
 
int main()
{ 
   using namespace MatrSpace;
   srand(static_cast<unsigned>(time(NULL)));
   ConsoleMatr<int> Ob1;
   size_t row, col;
   std::cout<<"Enter num of rows and cols for 1-st matrix: ";
   std::cin>>row>>col;
   Ob1.SetSize(row, col);
 
   int choise=0;
   std::cout<<"Enter 1 for fill matrix from keyboard\n"
      <<"Enter 2 for random fill matrix\n";
   std::cin>>choise;
   if(choise==1)
      std::cin>>Ob1;
   else if(choise==2)
      Ob1.random_fill();
   else
   {
      std::cerr<<"There is no such option\n";
      return 0;
   }
   std::cout<<std::endl;
   
   ConsoleMatr<int> Ob2;
   std::cout<<"Enter num of rows and cols for 2-nd matrix: ";
   std::cin>>row>>col;
   Ob2.SetSize(row, col);
 
   choise=0;
   std::cout<<"Enter 1 for fill matrix from keyboard\n"
      <<"Enter 2 for random fill matrix\n";
   std::cin>>choise;
   if(choise==1)
      std::cin>>Ob2;
   else if(choise==2)
      Ob2.random_fill();
   else
   {
      std::cerr<<"There is no such option\n";
      return 0;
   }
   std::cout<<std::endl;
   {
       
   std::cout<<"First matrix\n\n"<< Ob1 <<'\n';
   std::cout<<"Second matrix\n\n"<< Ob2 <<'\n';       
            //вывод сложения на экран
   ConsoleMatr<int> Ob3;
    try
   {
       Ob3=Ob1+Ob2;
   }
   catch(const std::invalid_argument&e) 
   {
      std::cout<<e.what()<<'\n';
      return 0;
   }
   std::cout<<"Summary of first matrix to second matrix\n\n";
   std::cout<<Ob3<<'\n';
  
}
//вывод умножения на экран
        ConsoleMatr<int> Ob4;
        try
        {
          Ob4=Ob1*Ob2;
           }
        catch(const std::invalid_argument&e) 
       {
         std::cout<<e.what()<<'\n';
          return 0;
             }
           std::cout<<"Multy of first matrix to second matrix\n\n";
            std::cout<<Ob4<<'\n';
            
 
//вывод вычитания на экран
        ConsoleMatr<int> Ob5;
        try
        {
          Ob5=Ob1-Ob2;
           }
        catch(const std::invalid_argument&e) 
       {
         std::cout<<e.what()<<'\n';
          return 0;
             }
           std::cout<<"Vichitanie of first matrix to second matrix\n\n";
            std::cout<<Ob5<<'\n';
 
 
            ConsoleMatr<int> Ob6;
            try
            { double LinesNorma(double** Ob6,int N,int M)
            {   double S=0;
                for(int i=0;i<N;i++)
                {   double St=0;
                    for(int j=0;j<M;j++)
                      St+=fabs(Ob6[i][j]);
                    if(S<St)
                       St=S;
               }
                catch(const std::invalid_argument&e) };
            {
               return S;
           }
            std::cout<<" norma matrix\n\n";
            std::cout<<Ob6<<'\n';
            }
}
//normmatric