Lookup function not working - c++

Question

I'm trying to have an algorithm that makes a DFA for a tic tac toe game. With the code I have right now, there are repeating states. I made a lookup function to see if the state already before adding it and add the already made state to a the parent state's vector of children.
I have tried implementing it, but I'm still getting the same number of nodes that I was getting before I implemented it meaning its never finding another state that with the same 'position' array and it is suppose to. I don't see what I'm doing wrong. It never returns anything.
UPDATE: I do know that it is returning to soon and not going through all the elements, but I don't know how to make it go through all the states and make it stop returning too soon.
UPDATE 2.0: So I've changed where my lookup is, it is now in my Main.cpp file. I also changed how it goes through, but it still isn't returning correctly.
Any ideas? Here is my code:
States.cpp
#include "States.hpp"
State::State(){
final = false;
reject = false;
draw = false;
for (int i = 0; i < 9; i++)
_position[i] = 2;
firstPlayerMove = true;
_children = new vector<State *> ();
};
void State::setStateChildren(State *s){
_children->push_back(s);
}
vector<State*> *State::getChildren(){
return _children;
}
void State::setFirstMove(bool b){
firstPlayerMove = b;
}
bool State::firstMove(){
return firstPlayerMove;
}
void State::setPosition(int p[]){
for (int i = 0; i < 9; i++){
_position[i] = p[i];
}
}
int *State::position(){
return _position;
}
bool State::isFinal(){
return final;
}
bool State::isReject(){
return reject;
}
Main.cpp
#include <iostream>
#include <vector>
#include "States.hpp"
using namespace std;
void dependents(State *root, State *state, bool first);
int size (State *s);
bool win(int p[], int symbol);
bool draw(int p[]);
void CreateDFA(State *root, State *state, int n){
if (n == 0 || state == nullptr)
return;
if (state->isFinal() || state->isReject() || state->isDraw())
return;
dependents(root, state, state->firstMove());
for (vector<State*>::iterator iter = state->getChildren()->begin(); iter != state->getChildren()->end(); iter++){
CreateDFA(root, *iter, n - 1);
}
}
void dependents(State *root, State *state, bool first){
int symbol;
if (first)
symbol = 1;
else
symbol = 0;
int count = 0;
while (count < 9){
if (state->position()[count] == 2 && state->position()[count] != 1 && state->position()[count] != 0){
int check[9];
for(int i = 0; i < 9; i++)
check[i] = state->position()[i];
check[count] = symbol;
State *child = root->find(root, check);
if (child == nullptr){
child = new State();
child->setPosition(state->position());
child->setFirstMove(!(state->firstMove()));
child->position()[count] = symbol;
child->setFinal(win(child->position(), 1));
child->setReject(win(child->position(), 0));
child->setDraw(draw(child->position()));
}
state->setStateChildren(child);
}
count++;
}
}
bool win(int p[], int symbol){
if(p[0] == symbol && p[1] == symbol && p[2] == symbol)
return true;
if(p[0] == symbol && p[4] == symbol && p[8] == symbol)
return true;
if(p[0] == symbol && p[6] == symbol && p[3] == symbol)
return true;
if(p[1] == symbol && p[4] == symbol && p[7] == symbol)
return true;
if(p[2] == symbol && p[4] == symbol && p[6] == symbol)
return true;
if(p[2] == symbol && p[5] == symbol && p[8] == symbol)
return true;
if(p[3] == symbol && p[4] == symbol && p[5] == symbol)
return true;
if(p[6] == symbol && p[7] == symbol && p[8] == symbol)
return true;
return false;
}
bool draw(int p[]){
if(p[0] != 2 && p[1] != 2 && p[2] != 2 && p[3] != 2 && p[4] != 2 && p[5] != 2 && p[6] != 2 && p[7] != 2 && p[8] != 2){
cout << "Set Draw" << endl;
return true;
}
return false;
}
int size (State *s){
if (s == nullptr)
return 0;
int count = 0;
for(vector<State*>::iterator iter = s->getChildren()->begin(); iter != s->getChildren()->end(); iter++)
count = size(*iter) + count;
return count + 1;
}
bool check(int p[], int a[]){
for(int i = 0; i < 9; i++)
if (p[i] != a[i])
return false;
return true;
}
State *find(State * root, int p[]){
if (root->isFinal() || root->isReject() || root->isDraw())
return nullptr;
State * s = nullptr;
for (vector<State*>::iterator iter = root->getChildren()->begin(); iter != root->getChildren()->end(); iter++){
if(check((*iter)->position(), p)){
s = new State (**iter);
break;
}
else
s = find((*iter), p);
}
return s;
}