Unknown Type Name when using threads

Question

I am trying to find the minimum vertex cover by giving the vertex and edge input in specific format from the user using threads. Here is my code:

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <cctype>
#include <list>
#include <set>
#include <vector>
#include <climits>
#include <memory>
#include <algorithm>
#include <pthread.h>
#include <unistd.h>
#include "minisat/core/Solver.h"
using namespace std;

static void *AVC2_Vertex_Cover(void *);

void min_vertex_cover_algorithm(Graph &graph_builder){
    int ret;
    pthread_t AVC2_thread;
    ret = pthread_create(&AVC2_thread, NULL, AVC2_Vertex_Cover, &graph_builder);
    if(ret)
        exit(1);
    pthread_join(AVC2_thread, NULL);
    pthread_exit(NULL);
}


struct Edge{
    unsigned v1,v2;
};

typedef std::vector<unsigned> Vertex_vector;
typedef std::list<unsigned > Vertex_Adjacency_list;
typedef std::vector<Vertex_Adjacency_list> Adjacency_Traversal_list;

struct Graph{
    std::size_t no_of_edges;
    Adjacency_Traversal_list adjacency_list;
    void initialize_graph(unsigned vertices_number);
    void construct_edge(Edge edge);
    void clear(unsigned vertex);
};


void Graph::initialize_graph(unsigned num){
    adjacency_list.clear();
    no_of_edges = 0;
    adjacency_list.resize(num,{});
}

void Graph::construct_edge(Edge edge) {
    auto &literal_1 = adjacency_list[edge.v1];
    auto &literal_2 = adjacency_list[edge.v2];
    literal_1.push_back(edge.v2);
    literal_2.push_back(edge.v1);
    no_of_edges ++;
}

void *AVC2_Vertex_Cover(void *input)
{
    Graph g = *(const Graph *)input;  
    unsigned int V = g.adjacency_list.size();
    bool visited[V];
    for (int i=0; i<V; i++)
        visited[i] = false;
 
    for (int u=0; u<V; u++)
    {
        if (visited[u] == false)
        {
            for(int x : g.adjacency_list[u])
            {
                int v = x;
                if (visited[v] == false)
                {
                    visited[v] = true;
                    visited[u]  = true;
                    break;
                }
            }   
        }
    }
    // Print the vertex cover
    std::cout << "APPROX-VC-2: ";
    for (int i=0; i<V; i++){
        if (visited[i])
            if(i == V-1)
                cout << i << std::endl; 
            else
                cout << i << ",";
    }
}


void *IO_thread(void *)
{
    Graph &graph_builder = *new Graph();
    char character_input;
    string my_input;
    unsigned int no_of_vertices = 0;
    string edge_stream;
    char prev_choice = ' ';

    while (getline(cin, my_input))  
    {
        istringstream stream_string(my_input);
        while (stream_string >> character_input) 
        {
            character_input=(toupper(character_input));
            try
            {
                switch (character_input)
                {
                    case 'V' :
                        if (prev_choice == 'V')
                        {
                            cerr << "Error: V must be followed by E only.\n";
                            break;
                        }
                        else
                        {
                            stream_string >> no_of_vertices;
                            if(no_of_vertices <= 0)
                            {
                                throw "Invalid number of vertices";
                            }       
                            graph_builder.initialize_graph(no_of_vertices);
                            prev_choice = 'V';
                            break;
                        }

                    case 'E' :
                    {
                        unsigned int flag_Entry = 0;
                        if ( prev_choice == 'E')
                        {
                            cerr << "Error: V and E always occur together.\n ";
                            break;
                        }
                        else
                        {
                            stream_string >> edge_stream;
                            istringstream edge_stream_character(edge_stream);
                            char edg_char;
                            unsigned int temp = 0;
                            unsigned int v1;
                            unsigned int v2;

                            edge_stream_character >> edg_char;

                            while (edg_char != '}') 
                            {
                                edge_stream_character >> edg_char;
                                if (edg_char == '}')
                                {
                                    flag_Entry = 1;
                                    break;
                                }
                                else
                                {
                                    edge_stream_character >> temp;
                                    v1 = temp;
                                    edge_stream_character >> edg_char;

                                    edge_stream_character >> temp;
                                    v2 = temp;

                                    edge_stream_character >> edg_char;
                                    edge_stream_character >> edg_char;
                                    if (v1 >= no_of_vertices || v2 >= no_of_vertices)
                                    {
                                        cerr << "Error: Vertex out of range.\n";
                                        graph_builder.adjacency_list.clear();
                                        break;
                                    }
                                    graph_builder.construct_edge({v1,v2});
                                }
                            }
                            if(flag_Entry == 1)
                            {
                                prev_choice = 'E';
                                break;
                            }
                            min_vertex_cover_algorithm(graph_builder);
                            prev_choice = 'E';
                            break;
                        }
                    }
                }
            }
            catch (const char* err)
            {
                cerr << "Error:" << err << endl;
            }
        }
    }
    return 0;
}

int main(int argc, char **argv){
    int ret;
    pthread_t IO_thread;
    ret = pthread_create(&IO_thread, NULL, IO_thread,NULL);
    if(ret)
        return 1;
    pthread_join(IO_thread,NULL);
    pthread_exit(NULL);
}

I am getting an error:

unknown type name 'Graph'
void min_vertex_cover_algorithm(Graph &graph_builder){

I am not able to find why this error is occuring. It will be very helpful if I get some solutions.

Answer 1

Just like you, the compiler will read from top to bottom. When it reaches the line:

void min_vertex_cover_algorithm(Graph &graph_builder){

It has to go, ok, lets use a Graph reference. It will look for the declaration of a Graph, which it cannot find, because you have declared (and defined) it below. To solve this, give the compiler a hint. Declare the Graph above the function with:

struct Graph;

void min_vertex_cover_algorithm(Graph &graph_builder){

Or simply move the whole struct definition above the function.