Ошибка в перегрузке операторов для класса - итератора

#include<iostream>
#include<iomanip>
#include<fstream>
#include<vector>    
using namespace std;
 
//-------------------------------------------------------------
 
enum Direction { d_up=0, d_right, d_down, d_left };
 
struct Cell {
    Cell(double a)
        : val(a), link_up(0), link_right(0), link_down(0), link_left(0) { }
 
    double val;
    
    Cell* link_up;
    Cell* link_right;
    Cell* link_down;
    Cell* link_left;
};
 
ostream& operator<<(ostream& ost, Cell& c)
{
    ost<<c.val;
    return ost;
}
ofstream& operator<<(ofstream& ofs, Cell& c)
{
    ofs<<c.val;
    return ofs;
}
 
//-------------------------------------------------------------
 
class Matrix_iterator {
public:
    Matrix_iterator(Cell* pr=0, Cell* p=0) : p_row(pr), pointer(p) { } 
 
    bool operator==(const Matrix_iterator& other)const { return p_row==other.p_row && pointer==other.pointer; }
    bool operator!=(const Matrix_iterator& other)const { return !(*this==other); } 
 
    Cell& operator*() { return *pointer; }
    Cell* operator->() { return pointer; }
 
    void advance(int n, Direction d); 
    Matrix_iterator& operator++();
private:
    Cell* p_row;
    Cell* pointer;
};
 
void Matrix_iterator::advance(int n, Direction d)
{
    switch(d) {
    case d_up:
        while (n) {
            pointer=pointer->link_up;
            p_row=p_row->link_up;
            --n;
        }
        break;
    case d_right:
        while (n) {
            pointer=pointer->link_right;
            --n;
        }
        break;
    case d_down:
        while (n) {
            pointer=pointer->link_down;
            p_row=p_row->link_down;
            --n;
        }
        break;
    case d_left:
        while (n) {
            pointer=pointer->link_left;
            --n;
        }
    }
}
 
Matrix_iterator& Matrix_iterator::operator++()
{
    if (pointer->link_right==0) {
        p_row=p_row->link_down;
        pointer=p_row;
    }
    else pointer=pointer->link_right;
    return *this;
}
 
//-------------------------------------------------------------
 
class LMatrix {
public:
 
    /*class iterator;*/
 
    LMatrix(int r, int c, double def=0);
    //LMatrix(const LMatrix& source);       
 
    Matrix_iterator begin() { return Matrix_iterator(first,first); }
 
    Matrix_iterator end() { return Matrix_iterator(0,0); }  //позиция за последним элементом матрицы, т.е. строка=rows, столбец=0
    
    int count_rows()const { return rows; }
    int count_cols()const { return cols; }
 
    
    //~LMatrix();
private:
    int rows;
    int cols;
 
    Cell* first; 
};
 
LMatrix::LMatrix(int r, int c, double def)
    : rows(r), cols(c)
{
    vector<Cell*> v;
    first=new Cell(def);        //установка first
    v.push_back(first);
 
    //первый столбец, установка указателей up/down
    for (int i=1; i<rows; ++i) {
        v.push_back(new Cell(def));
        v[i-1]->link_down=v[i];
        v[i]->link_up=v[i-1];
    }
 
    //формирование строк
    for (int i=0; i<v.size(); ++i) {
        Cell* prev(v[i]);
        Cell* succ(v[i]);               
        for (int j=1; j<cols; ++j) {
            prev->link_right=new Cell(def);
            succ=prev->link_right;
            succ->link_left=prev;
            prev=succ;
        }
    }
 
    //установка указателей up/down для столбцов с 1 по (cols - 1)
    for (int i=1; i<cols; ++i) {
        for (int j=0; j<v.size(); ++j) 
            v[j]=v[j]->link_right;
        for (int k=1; k<v.size(); ++k) {
            v[k-1]->link_down=v[k];
            v[k]->link_up=v[k-1];
        }
    }
    
}
 
//Ввод матрицы целиком
istream& operator>>(istream& ist, LMatrix& M)
{
    double temp;
    for (Matrix_iterator it=M.begin(); it!=M.end() && ist>>temp; ++it)
        *it=temp;
    return ist;
}
ifstream& operator>>(ifstream& ifs, LMatrix& M)
{
    double temp;
    for (Matrix_iterator it=M.begin(); it!=M.end() && ifs>>temp; ++it)
        *it=temp;
    return ifs;
}
 
//Вывод матрицы целиком
ostream& operator<<(ostream& ost, /*const*/ LMatrix& M)
{
    int nrows=M.count_rows();
    int ncols=M.count_cols();
 
    ost<<' '<<' ';
    const int width=7;
    for (int i=0; i<ncols; ++i)
        ost<<setw(width)<<internal<<i;
    ost<<endl;
    for (int i=0; i<width*ncols+2; ++i)
        ost<<'-';
    ost<<endl;
 
    Matrix_iterator it=M.begin();
    for (int i=0; i<nrows; ++i) {
        ost<<i<<'|';
        for (int j=0; j<ncols; ++j, ++it)
            ost<<setw(width)<<internal<<*it;
        ost<<endl;
    }
    return ost;
}
 
 
//-------------------------------------------------------------
 
 
int main()
{   
    LMatrix M(3,3,2.1);
    cout<<M<<endl;
    cin>>M;
    cout<<M<<endl;
    system("pause");
    return 0;
}