Iterator Conversion problem?

#pragma once

#include "stdafx.h"
#include "VisibleGameObject.h"

enum Quadrant { NONE = 0, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, };
enum NodeType { BRANCH = 99, LEAF };

class QuadTreeNode;

typedef std::set<VisibleGameObject*> ObjectSet;
typedef std::set<QuadTreeNode*> NodeSet;

class QuadTree
{
public:
	QuadTree( float width, float height, unsigned int maxObjects );
	QuadTreeNode* CreateNode( float x, float y, float w, float h, Quadrant quad, QuadTreeNode* parent = NULL );
	void Divide( QuadTreeNode* parent );
	void TransferListDown( QuadTreeNode* parent, QuadTreeNode* child );
	void TransferListUp( QuadTreeNode* parent, QuadTreeNode* child );
	bool CheckNodeBounds( VisibleGameObject* object, QuadTreeNode* node );
	void Update( float elapsedTime );

protected:
	float _width;
	float _height;
	unsigned int _maxObjects;
	ObjectSet CollideList;
	NodeSet NodeList;
};

#include "stdafx.h"
#include "Quadtree.h"
#include "QuadTreeNode.h"


QuadTree::QuadTree( float width, float height, unsigned int maxObjects ) : _width( width ),
	_height( height ), _maxObjects( maxObjects )
{
}

QuadTreeNode* QuadTree::CreateNode( float x, float y, float w, float h, Quadrant quad, QuadTreeNode* parent )
{
	if( parent != NULL )
	{
		if( parent->_nodeType == NodeType::BRANCH )
		{
			QuadTreeNode* newNode = new QuadTreeNode( x, y, w, h, quad, NodeType::LEAF, parent );
			return newNode;
		}

		if( parent->_nodeType == NodeType::LEAF )
		{
			QuadTreeNode* newNode = new QuadTreeNode( x, y, w, h, quad, NodeType::LEAF, parent );
			parent->_nodeType = NodeType::BRANCH;
			return newNode;
		}
	}

	else
	{
		QuadTreeNode* newNode = new QuadTreeNode( x, y, w, h, quad, NodeType::BRANCH, NULL );
		return newNode;
	}	
}

void QuadTree::Divide( QuadTreeNode* parent )
{
	// Get the parent node width, height, x and y
	float w = parent->_width;
	float h = parent->_height;
	float x = parent->_posX;
	float y = parent->_posY;

	// Top Left
	QuadTreeNode* child =  CreateNode( x, y, w * 0.5f, h * 0.5f, Quadrant::TOP_LEFT, parent );
	bool exists = NodeList.find( child ) != NodeList.end();

	if( !exists )
	{
		NodeList.insert( child );
		TransferListDown( parent, child );
	}

	else
		delete child;

	// Top Right
	child = CreateNode( x + ( w * 0.5f ), y, w * 0.5f, h * 0.5f, Quadrant::TOP_RIGHT, parent );
	exists = NodeList.find( child ) != NodeList.end();

	if( !exists )
	{
		NodeList.insert( child );
		TransferListDown( parent, child );
	}

	else
		delete child;

	// Bottom Left
	child = CreateNode( x, y + ( h * 0.5f ), w * 0.5f, h * 0.5f, Quadrant::BOTTOM_LEFT, parent );
	exists = NodeList.find( child ) != NodeList.end();

	if( !exists )
	{
		NodeList.insert( child );
		TransferListDown( parent, child );
	}

	else
		delete child;

	// Bottom Right
	child = CreateNode( x + ( w * 0.5f ), y + ( h * 0.5f ), w * 0.5f, h * 0.5f, Quadrant::BOTTOM_RIGHT, parent );
	exists = NodeList.find( child ) != NodeList.end();

	if( !exists )
	{
		NodeList.insert( child );
		TransferListDown( parent, child );
	}

	else
		delete child;
}

void QuadTree::TransferListDown( QuadTreeNode* parent, QuadTreeNode* child )
{
	// This function will transfer all objects from the parent list to the children's list
	for( ObjectSet::iterator x = parent->_CollideList.begin(); x != parent->_CollideList.end(); x++ )
	{
		if( CheckNodeBounds( (*x), child ) )
		{
			child->_CollideList.insert( x );
			parent->_CollideList.erase( x );
		}

		else
			continue;
	}
}

void QuadTree::TransferListUp( QuadTreeNode* parent, QuadTreeNode* child )
{
	
}

bool QuadTree::CheckNodeBounds( VisibleGameObject* object, QuadTreeNode* node )
{
	sf::Rect<float> rect;
	rect.Left = node->_posX;
	rect.Right = node->_posX + node->_width;
	rect.Top = node->_posY;
	rect.Bottom = node->_posY + node->_height;

	return rect.Intersects( object->GetBoundingRect(), &rect );
}

Quote

CheckNodeBounds( (*x), child );