I m getting linking errors
like
Dijkstra's error LNK2019: unresolved external symbol "public: __thiscall List<struct Path_store>::List<struct Path_store>(void)" (??0?$List@UPath_store@@@@
QAE@XZ) referenced in function "public: __thiscall Interface::Interface(void)
" (??0Interface@@QAE@XZ)
I m giving my 3 files Interface.h , linklst.cpp and .h file as I think these are related.
Interface.h
#ifndef INTERFACE_H
#define INTERFACE_H
// Header Files
#include "iostream" // Input & Output
#include "stdlib.h" // Use of std lib functions such as exit()
#include "stdio.h" // Use of Input and Output Streams
#include "apvector.h" // Used apvectors in the program
#include "Listlnk.h" // Use of member functions of the list class
using namespace std;
// --------------------------
----------
----------
----------
----------
----------
-
// Structure for the input provided by the user
struct UserInput
{
int vertex_1; // Stores the first vertex
int vertex_2; // Stores the second vertex
int Edge_Len; // stores the length of the edge formed by the
// 2 vertices
};
// --------------------------
----------
----------
----------
----------
----------
-
// Structure for the priority queue of the Dijkstra's Algorithm
struct Prior_Q
{
int vertex ; // Stores the Vertices of the Graph
int Source_Dist; /* Stores the distance of that vertex from the source
vertex initially all but the source = -1.
-1 implies that the cost of path to that vertex
from the source is infinit */
};
// --------------------------
----------
----------
----------
----------
----------
-
// Structure for the Shortest/Min cost Path Storage at a given instance.
struct Path_store
{
int vertex; // Stores the vertex in the sloution set 'S'
int Ver_Dist; // Stores the shortest distance from the source.
apvector<int> path; // Stores the shortest path to this vertex from the
// source
};
//------------------------
----------
----------
----------
----------
----------
----
// Class Interface
class Interface
{
// --------------------------
----------
----------
----------
----------
---------
public:
// Constructor of the class
Interface();
//------------------------
----------
----------
----------
----------
----------
----
// Input Functions
// Store the source and the end destination to the private data members.
void store_source_sink ( int source, int sink);
// Input the graph values
void input_graph(int vert_1, int vert_2, int pathLen);
// Error if same set of vertices is found in the Input List
bool same_vert_error (int vert1, int vert2);
//------------------------
----------
----------
----------
----------
----------
----
// Priority Queue Functions
// Add vertex to priority queue if it does not already exist in the priority
// queue.
void add_to_pqueue(int vert);
// Sort the priority queue according to distance of the vertex from the source
// vertex. A value of -1 implies infinity.
void sort_pqueue_dist();
// Sort the priority the queue according to vertex number
// Adds the vertex at the appropriate place.
void sort_pqueue_vert(Prior_Q &queue);
// Search the priority Q (already sorted) for a certain vertex.
// Leave the cursor at the element if found.
bool search_pqueue_vert(int key_Vert);
// Returns true if the priority queue head position implies
// there is only one element in the p-Queue
bool is_q_at_end();
//Pops the top element of the priority queue
void remove_top( Prior_Q &temp);
// Replaces the distance from the source for the vertex marked by the cursor
void replace_dist_inQ(int dist);
//------------------------
----------
----------
----------
----------
----------
----
// Path Store operations
// Adds a vertex along with its distance from the source and the corresponding
// path to the path storage.
void add_to_path(int vert, int dist, apvector<int> path);
// Searches the passed vertex and return true if it is found in the Path Store
// List
bool searchvert_in_path(int active_vert);
// Add the shortest path for a vertex to the PathStore structure.
void add_shortest_path( int vertex, int Path_Size, apvector<int> path);
// Relax the neighbouring edges and evaluate the distances of the correspoding
// vertex/Ces to the Source.
void relax_edge(int Active_vertex);
//------------------------
----------
----------
----------
----------
----------
----
// Searches for the passsed vertex in the sloution set of the Dijkstra's
// Algorithm
bool searchVertin_solnset(int vert);
//------------------------
----------
----------
----------
----------
----------
----
// Display the output. The path and shortest length
void show_result();
//------------------------
----------
----------
----------
----------
----------
----
private:
// private data members.
int source; // Stores the source vertex while finding the shortest
// path
int sink; // Stores the vertex to which the shortest path from the
// source is intended to.
List<UserInput> input; // Stores the graph vertices along with the
// corresponding edge lengths.
List<Prior_Q> P_Queue; // Stores the priority queue of the Dijkstra's Algorithm
List<Path_store>Path; // Stores the shortest path & the value to a vertex
// from a given source at a given time.
apvector<int> SolnSet; // Stores the vertices already dealt with permanently.
// Stores the solution set of Dijkstra Algorithm.
};
#endif
Linklst.h
#ifndef LISTLNK_H
#define LISTLNK_H
template <class LE>
class List;
template < class LE >
class ListNode // Facilitator class for the List class
{
public:
// Constructor
ListNode ( const LE &elem, ListNode *nextPtr );
// Data members
LE element;
ListNode *next;
friend class List<LE>;
};
//------------------------
----------
----------
----------
----------
----------
----
template <class LE>
class List
{
public:
// Constructor
List ( );
void insert (const LE &newElement ); // Insert after cursor
void remove (); // Remove Element
void replace ( const LE &newElement ); // Replace Element
void clear (); // Clear List
// List status operations
int empty () const; // List is empty
int full () const; // List is full
// List iteration operations
int gotoBeginning (); // Go To Beginning
int gotoEnd (); // Go to End
int gotoNext (); // Go to next element
int gotoPrior (); // Go to prior element
LE getCursor () const; // Return element
int getLength(); // Returns the length of the list
bool isAtEnd () const; // Returns true if the cursor is at
// end of the list
// Output the list structure -- used in testing/debugging
void showStructure () const;
// In-lab oprations
void moveToBeginning () ; // Move to beginning
void insertBefore ( const LE &newElement ); // Insert before cursor
private:
// Data members
ListNode<LE> *head, *cursor; // Pointer to the beginning of the list
// Cursor pointer
friend class Interface;
friend class ListNode<LE>;
};
#endif
linklst.cpp
// Header Files
#include "iostream.h" // Input and Ouput
#include "listlnk.h" // Implementation of the list functions
//------------------------
----------
----------
----------
----------
----------
----
// ListNode Class Constructor
template <class LE>
ListNode<LE>::ListNode ( const LE &elem, ListNode *nextPtr )
{
element = elem;
next = nextPtr;
}
//------------------------
----------
----------
----------
----------
----------
----
// List Class Constructor
template <class LE>
List<LE>:: List ()
{
head = NULL;
cursor = NULL;
}
//------------------------
----------
----------
----------
----------
----------
----
//List class insert function. Inserts after cursor position
template <class LE>
void List<LE> :: insert ( const LE &newElement )
{
if(!full())
{
if(!empty())
{
ListNode<LE> *temp1;
temp1 = cursor;
cursor = new ListNode<LE>( newElement, cursor->next);
temp1->next = cursor;
}
else
{
cursor = new ListNode<LE> ( newElement, NULL);
head = cursor;
}
}
}//end of void
//------------------------
----------
----------
----------
----------
----------
----
// List class remove function. remove element marked by cursor
template <class LE>
void List<LE> :: remove ()
{
if(!empty())
{
ListNode<LE> *temp1;
temp1 = head;
if( head != cursor )
{
while(temp1->next != cursor)
temp1 = temp1->next;
temp1->next = cursor->next;
temp1 = cursor;
if( cursor ->next !=NULL)
cursor = cursor -> next;
else
cursor = head;
delete [ ] temp1;
}
else
if( cursor->next == NULL )
{
temp1 = cursor;
cursor = NULL;
head = NULL;
delete [ ] temp1;
}
else
if( cursor->next != NULL)
{
temp1 = head;
head = head->next;
cursor = head;
delete temp1;
}
}
};
//------------------------
----------
----------
----------
----------
----------
----
// List class replace function . replaces the element marked by the cursor
template <class LE>
void List<LE>::replace( const LE &newElement )
{
if ( ! empty ( ) )
{
cursor->element = newElement;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// List class clear function. Clears the list
template<class LE>
void List<LE>::clear( )
{
cursor = head;
while ( cursor !=NULL )
{
head = cursor->next;
delete [ ] cursor;
cursor = head;
}
}//end of void
//------------------------
----------
----------
----------
----------
----------
----
// List class empty status function
template <class LE>
int List<LE> :: empty ( ) const
{
if ( cursor == NULL ) // returns if 1 empty
return 1;
else
return 0;
}
//------------------------
----------
----------
----------
----------
----------
----
// List class full status function
template <class LE>
int List<LE>::full ( ) const
{
ListNode<LE> *temp;
if( temp == NULL )
return 1; // returns 1 is full
else
return 0; // returns 0 otherwise
}
//------------------------
----------
----------
----------
----------
----------
----
// List class go to Begin function. Cursor moves to the beginning
template <class LE>
int List<LE>::gotoBeginning ()
{
if(! empty ())
{
cursor = head;
return 1;
}
else
{
return 0;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// List class go to end function. Cursor moves to the end of the list
template <class LE>
int List<LE>::gotoEnd ()
{
if(! empty () )
{
while (cursor->next != NULL)
cursor = cursor->next;
return 1;
}
else
{
return 0;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// List class to go Next function Cursor moves to the next element in the list
template <class LE>
int List<LE>::gotoNext ()
{
if(!empty ())
{
if(cursor->next !=NULL)
{
cursor = cursor->next;
return 1;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// List class getcursor for Returns the element marked by the cursor
template <class LE>
LE List<LE>::getCursor () const
{
if(!empty ())
{
return cursor->element;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// List class goto Prior function Cursor moves to the prior element
template <class LE>
int List<LE>::gotoPrior ()
{
if(!empty() && head!=cursor )
{
ListNode<LE> * temp;
temp = head;
while(temp->next != cursor)
temp = temp->next;
cursor = temp;
return 1;
}
else
{
return 0;
}
}
//------------------------
----------
----------
----------
----------
----------
----
template <class LE>
void List<LE>::showStructure () const
// Outputs the elements in a list. If the list is empty , outputs
// "Empty List". This operation is intended for testing and debugging purpose only
{
ListNode<LE> *p; // Interface through the list
if ( head == 0 )
cout << "Empty list" << endl;
else
{
for( p = head; p!= 0; p = p->next )
if ( p == cursor )
cout << "[" << p->element << "] ";
else
cout << p->element << " ";
cout << endl;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// Returns the number of nodes in the linked list.
template <class LE>
int List<LE>::getLength()
{
if(empty())
return 0;
else
{
ListNode<LE> *temp;
temp = cursor;
int i = gotoBeginning();
int count = 1;
while( cursor->next !=NULL)
{
cursor = cursor->next;
count++;
}
cursor = temp;
return count;
}
}
//------------------------
----------
----------
----------
----------
----------
----
// List class insertbefore function. Inserts a new node before the position
// marked by the cursor.
template <class LE>
void List<LE>::insertBefore ( const LE &newElement )
{
if(!full())
{
if(!empty() && head != cursor)
{
ListNode<LE> *temp;
temp = head;
while( temp->next != cursor)
temp = temp->next;
cursor = new ListNode<LE> ( newElement, cursor)
temp->next = cursor;
}
else
{
cursor = new ListNode<LE> ( newElement, cursor);
head = cursor;
}
}
}
//------------------------
----------
----------
----------
----------
----------
----
// Returns true if the cursor is at the end of the list else returns false
template <class LE>
bool List<LE>::isAtEnd() const
{
if(!empty())
{
if( cursor->next == NULL)
return true;
else
return false;
}
return false;
}
What can be the reason calling this linking problem....
I need help on this problem immediately...I m doing a mesh project in the uni which is due soon and I m stuck on this linker error
Regards
Harsimrat
