Unweighted directed graph dfs_iterator operator++ C++ - c++

Question

I am working on the construction of the graph (unweighted, directed) class that accepts dfs_iterator and bfs_iterator with operations ++ to move to next value, * to get current vertex, == and != to compare the vertices. I am implementing the code in C++. The graph class is implemented using an adjacency list and it has private members vector<VType> vertices, vector<list<size_t>> adj_list and member functions add_vertex(vertex), add_edge(index1, index2), remove_edge(index1, index2), get_vertex(index), has_edge(index1, index2), get_neighbors(index) etc., and within the graph class I've implemented dfs_iterator class that does ++, *, ==, != operations. Below is the code I am trying to implement.
class graph {
private:
std::vector<VType> vertices;
std::vector<std::list<std::size_t>> adj_list;
public:
//... other member function implementations ...//
class dfs_iterator {
private:
std::vector<std::list<std::size_t >> adjList; // to hold the adj_list of graph class
std::vector<VType> vertexProp; //to hold the vertices of graph class
std::size_t index; // to keep track of current index
std::list<std::size_t>::iterator li_it; // to handle the list of each adjList[index]
public:
dfs_iterator(std::vector<std::list<std::size_t >> adj_list_, std::vector<VType> vertex_props_, std::size_t start_idx) {
this->adjList = adj_list_;
this->vertexProp = vertex_props_;
this->index = start_idx;
this->li_it = adjList[index].begin();
};
VType &operator*() {
return vertexProp[index];
};
dfs_iterator &operator++() { // explanation in the description below
if (this->li_it != adjList[index].end()) { // iterating over the depth until we hit the leaf with zero elements
this->index = *li_it; // jumping to index of list element
li_it = adjList[index].begin(); // changing the li_it to new list
} else {
/* have to handle the cases where we hit the end and search from a new branch of the parent and keep doing all the possible paths are closed. */
}
return *this;
};
};
dfs_iterator dfs_begin(std::size_t vertex_idx) {
return dfs_iterator(adj_list, vertices, vertex_idx);
};
dfs_iterator dfs_end(std::size_t vertex_idx) {
return dfs_iterator(adj_list, vertices, vertex_idx);;
};
}
}
Now, my * oepration works as expected but the ++ operator has few issues.
if my adjacency list is as mentioned below:
**index. list_of_neighbours/edges**
0. {4, 2, 6, 8}
1. {3, 5}
2. {}
3. {7}
4. {3}
5. {}
6. {}
7. {8}
8. {}
on doing
string delim = "";
for (auto it = graph.dfs_begin(0); it != graph.dfs_end(8); ++it) {
cout << delim << *it;
delim = " -> ";
}
cout << "\n";
my output is:
Traversing the graph in depth first fashion:
0 -> 4 -> 3 -> 7
as expected. but if in the 0th index, instead of {4, 2, 6, 8} my neighbors list is {2, 4, 6, 8}, then my operator++ on checking the list in index 2, which is dead, it should retreat from proceeding further and start from 2nd item of 0th index, i.e., 4 and dfs 0 -> 4 -> 3 -> 7.
I am looking for any suggestions or tips that help me proceed further. Open to answer further queries.