Где здесь ошибки? Почему крашится?

#include "stdafx.h"
#include <math.h>
#include <iostream>
#define MAX_DEGREE 340
#define MAX_LINE 4
using namespace std;
 
struct Pos
{
    float x, y;
    Pos(void){x=0;y=0;}
    Pos(float _x, float _y){x=_x; y=_y;}
    void operator= (Pos& apos){x = apos.x; y = apos.y;}
    void Print(int level, int count)
    {
        printf("Level %i count %i posX %f posY %f \n",level,count, x, y);
    }
};
 
class Node
{
public:
    class Iterator
    {
    public:
        Node* current;
        int index;
        int level;
 
        Iterator(){current = NULL; index = 0; level = 0;}
        ~Iterator(){}
 
        void operator= (Iterator &it);
        bool operator!= (Iterator &it);
        Iterator& operator++(int k);
        void NextNode();
        void NextLine();
        bool EndLine();
    };
public:
    Node(void);
    ~Node(void);
    void Set();
    void Find(int level, int& count);
    bool Check();
    Iterator begin(){return m_begin;}
    Iterator end(){return m_end;}
protected:
    void MakeThree(int degree, Node* root, Pos pos);
protected:
    Node* ch1;
    Node* ch2;
    Node* ch3;
    Node* ch4;
    Node* m_root;
    Pos m_Pos;
    int index;
    Iterator m_begin;
    Iterator m_end;
};
 
void Node::Iterator::operator=( Iterator &it )
{
    current = it.current;
    level = it.level;
    index = it.index;
}
 
bool Node::Iterator::operator!=( Iterator &it )
{
    if (current != it.current)
        return true;
    else
        return false;
}
 
Node::Iterator& Node::Iterator::operator++( int k )
{
    if (current->m_root == NULL)
    {
        current = current->ch1;
        level++;
        index++;
        return *this;
    }
    if (current == current->m_root->ch1)
    {
        current = current->m_root->ch2;
        index++;
        return* this;
    }
    if (current == current->m_root->ch2)
    {
        current = current->m_root->ch3;
        index++;
        return* this;
    }
    if (current == current->m_root->ch3)
    {
        current = current->m_root->ch4;
        index++;
        return* this;
    }
    if (current == current->m_root->ch4)
    {
        NextNode();
        return* this;
    }
}
 
void Node::Iterator::NextNode()
{
    if (current->m_root->m_root == NULL)
        NextLine();
    if (current == current->m_root->m_root->ch1->ch4)
    {
        current = current->m_root->m_root->ch2->ch1;
        index++;
    }
    if (current == current->m_root->m_root->ch2->ch4)
    {
        current = current->m_root->m_root->ch3->ch1;
        index++;
    }
    if (current == current->m_root->m_root->ch3->ch4)
    {
        current = current->m_root->m_root->ch4->ch1;
        index++;
    }
    if (current == current->m_root->m_root->ch4->ch4)
    {
        if (EndLine())
        {
            NextLine();
        }
        else
        {
            NextNode();
        }
    }
}
 
bool Node::Iterator::EndLine()
{
    Node* root /*= current->m_root*/;
    while (root->m_root->m_root != NULL)
    {
        if (root == root->m_root->ch4)
            root = root->m_root;
        else 
            return false;
    }
    return true;
}
 
void Node::Iterator::NextLine()
{
    if (level == MAX_LINE)
    {
        current = NULL;
        return;
    }
    while(current->m_root != NULL)
    {
        current = current->m_root;
    }
    for (int i = 0; i <= level+1; i++)
    {
        current = current->ch1;
    }
    level++;
    index++;
    return;
}
 
Node::Node( void )
{
    ch1 = NULL;
    ch2 = NULL;
    ch3 = NULL;
    ch4 = NULL;
    m_root = NULL;
    m_Pos;
    index = 0;
    m_end.current = NULL;
}
 
Node::~Node( void )
{
}
 
void Node::Set()
{
    int degree = 16;
    m_begin.current = this;
    MakeThree(degree, NULL, m_Pos);
}
 
void Node::MakeThree( int degree, Node* root, Pos pos )
{
    if(degree%2 != 0)
        return;
    m_root = root;
    ch1 = new Node;
    ch1->m_Pos = Pos(m_Pos.x+(float)degree/4, m_Pos.y +(float)degree/4);
    ch2 = new Node;
    ch2->m_Pos = Pos(m_Pos.x + (float)degree/4, m_Pos.y - (float)degree/4);
    ch3 = new Node;
    ch3->m_Pos = Pos(m_Pos.x - (float)degree/4, m_Pos.y - (float)degree/4);
    ch4 = new Node;
    ch4->m_Pos = Pos(m_Pos.x - (float)degree/4, m_Pos.y + (float)degree/4);
    ch1->MakeThree(degree/2, this, ch1->m_Pos);
    ch2->MakeThree(degree/2, this, ch2->m_Pos);
    ch3->MakeThree(degree/2, this, ch3->m_Pos);
    ch4->MakeThree(degree/2, this, ch4->m_Pos);
}
 
void Node::Find( int level, int& count )
{
    if(!Check())
        return;
    ch1->m_Pos.Print(level, count++);
    ch2->m_Pos.Print(level, count++);
    ch3->m_Pos.Print(level, count++);
    ch4->m_Pos.Print(level, count++);
    ch1->Find(level+1, count);
    ch2->Find(level+1, count);
    ch3->Find(level+1, count);
    ch4->Find(level+1, count);
}
 
bool Node::Check()
{
    if((ch1!=NULL)&&(ch2!=NULL)&&(ch3 != NULL)&&(ch4!=NULL))
        return true;
    else
        return false;
}
 
 
 
int main()
{
    setlocale(LC_ALL, "RUSSIAN");
    system("color E");
 
    Node Three;
    Three.Set();
    Node::Iterator It;
    It = Three.begin();
    for (;It != Three.end();It++)
    {
        cout<<It.index<<" "<<It.level<<" ";
        cout<<endl;
    }
    
    return 0;
}