Абстрактный шаблонный класс

    //Класс матрицы
    template<class T>
    class Matr
    {
    public:
       Matr();
       Matr(size_t n, size_t m);
       Matr(const Matr&);
       virtual ~Matr();
       void SetSize(size_t n, size_t m);
       const size_t GetRow() const {return Matrix.size();}
       const size_t GetCol() const {return Matrix[0].size();}
       template<class T2>
       friend std::ostream& operator <<(std::ostream& os, const Matr<T2>& Ob);
       template<class T2>
       friend std::istream& operator >>(std::istream& is, Matr<T2>& Ob);
       Matr<T>& operator =(const Matr&);
       Matr<T> operator +=(const Matr&);
       Matr<T> operator +(const Matr&);
       Matr<T> operator *=(const Matr&);
       Matr<T> operator *(const Matr&);
       void random_fill();
    protected:
       std::vector<std::vector<T> > Matrix;
    };

template<class T>
class ConsoleMatr:public Matr<T>
{
public:
   ConsoleMatr():Matr() {}
   ConsoleMatr(size_t n, size_t m):Matr(n, m) {}
   ConsoleMatr(const Matr& Ob):Matr(Ob) {}
   template<class T2>
   friend std::ostream& operator <<(std::ostream& os, const ConsoleMatr<T2>& Ob);
   template<class T2>
   friend std::istream& operator >>(std::istream& is, ConsoleMatr<T2>& Ob);
};

typedef std::auto_ptr<Matr<int> > MatrSP;
 
int main()
{
   MatrSP Ob(new ConsoleMatr);
   std::cin>>Ob;
   //
}

    //Класс матрицы
    template<class T>
    class Matr
    {
    public:
       Matr();
       Matr(size_t n, size_t m);
       Matr(const Matr&);
       virtual ~Matr();
       void SetSize(size_t n, size_t m);
       const size_t GetRow() const {return Matrix.size();}
       const size_t GetCol() const {return Matrix[0].size();}
       template<class T2>
       friend std::ostream& operator <<(std::ostream& os, const Matr<T2>& Ob);
       template<class T2>
       friend std::istream& operator >>(std::istream& is, Matr<T2>& Ob);
       Matr<T>& operator =(const Matr&);
       Matr<T> operator +=(const Matr&);
       Matr<T> operator +(const Matr&);
       Matr<T> operator *=(const Matr&);
       Matr<T> operator *(const Matr&);
       void random_fill();
           virtual void input()=0;
           virtual void output()=0;
    protected:
       std::vector<std::vector<T> > Matrix;
    };

template<class T>
class ConsoleMatr:public Matr<T>
{
public:
   ConsoleMatr():Matr() {}
   ConsoleMatr(size_t n, size_t m):Matr(n, m) {}
   ConsoleMatr(const Matr& Ob):Matr(Ob) {}
   template<class T2>
   friend std::ostream& operator <<(std::ostream& os, const ConsoleMatr<T2>& Ob);
   template<class T2>
   friend std::istream& operator >>(std::istream& is, ConsoleMatr<T2>& Ob);
   void input();
   void output();
};

    template<class T>
    Matr<T> Matr<T>::operator *(const Matr<T> &Ob)
    {
          Matr<T> Obj(*this);   
          Obj*=Ob;
          return Obj;
    }

MatrSP Ob(new ConsoleMatr<int>)

#include <boost/shared_ptr.hpp>
typedef boost::shared_ptr<Matr<int> > MatrSP;
 
int main(){
    MatrSP sp( new ConsoleMatr<int> );
}

template<class T2>
std::ostream& operator <<(std::ostream& os, const Matr<T2>& Ob)
{
    Ob.output(os);
    return os;
}
 
template<class T2>
std::istream& operator >>(std::istream& is, Matr<T2>& Ob)
{
    Ob.input(is);
    return is;
}

class MatrBase  // абстракный
{
public:
    virtual ~MatrBase() = 0 {}
 
    virtual
    MatrBase * clone() const = 0;  // клонируем себя
 
    void mult_op(MatrBase const * other)
    {
        // умножить *this на *other используя интерфейс MatrBase
    }
};
 
class ConsoleMatr : public MatrBase  // конкретный
{
public:
    ConsoleMatr * clone() const
    {
        return new ConsoleMatr(*this);
    }
};
 
class Matr  // handle
{
public:
    Matr(MatrBase * body) : m_body(body) {}
    ~Matr() { delete m_body; }
 
    Matr operator*(Matr const & other) const
    {
        MatrBase * product = other.m_body->clone();
        product->mult_op(m_body);
        return Matr(product);
    }
private:
    MatrBase * m_body;
};

Matr Matr::operator*(Matr const & rhs) const
{
    // умножаем *this на rhs, оба одного типа, Matr
}
 
ConsoleMatr ConsoleMatr::operator*(ConsoleMatr const & rhs) const
{
    // умножаем *this на rhs, оба одного типа, ConsoleMatr
}

ConsoleMatr m1;
ConsoleMatr m2;
ConsoleMatr m3 = m1 * m2;

std::auto_ptr<Matr<int> > Ob(new ConsoleMatr<int>);

std::auto_ptr<Matr<int> > Ob(new ConsoleMatr<int>);
std::auto_ptr<Matr<int> > Ob2(new ConsoleMatr<int>);
std::auto_ptr<Matr<int> > Ob3 = ???

std::auto_ptr<Matr<int> > Ob3(new ConsoleMatr<int>);
*Ob3=*Ob1 * *Ob2;

template<class T>
class Int
{
public:
    Int(){a=5;}
    virtual void input(){}
    virtual void output(){}
    Int<T> operator+(const Int<T>& Ob)
    {
        Int Temp;
        Temp.a=a+Ob.a;
        return Temp;
    }
protected:
    T a;
};
 
template<class T>
class ConsoleInt:public Int<T>
{
public:
    ConsoleInt():Int() {}
    void input()
    {
        std::cin>>a;
    }
    void output()
    {
        std::cout<<a<<'\n';
    }
};

#include <iostream>
#include <memory>
 
#include "xfd.h"
 
int main()
{
    std::auto_ptr<Int<int> > Ob(new ConsoleInt<int>);
    Ob->input();
    Ob->output();
    std::auto_ptr<Int<int> > Ob2(new ConsoleInt<int>);
    Ob2->input();
    Ob2->output();
    std::auto_ptr<Int<int> > Ob3(new ConsoleInt<int>);
    *Ob3=*Ob+*Ob2;
    Ob3->output();
    return 0;
}