Laboratory Exercises, C++ Programming

Tools for Practical C++ Development 21
/* insert an arc from the vertex ‘from’ to the vertex ‘to’ */
void add_arc(const std::string& from, const std::string& to);
/* return the vertex names in reverse topological order */
std::stack top_sort() throw(cyclic);
/* print the vertex list (for debugging) */
void debugPrint() const;
private:
void insert(Vertex* v); // insert the vertex pointer v in vptrs, if
// it’s not already there
Vertex* find(const std::string& name) const; // return a pointer to the
// vertex named name, 0 if not found
void dfs_visit(Vertex* v, std::stack& result) throw(cyclic);
// visit v in the traversal algorithm
};
std::vector vptrs; // vector of pointers to vertices
VertexList(const VertexList&); // forbid copying
VertexList& operator=(const VertexList&);
Finally, the class Graph is merely a typedef for a VertexList:
Notes:
typedef VertexList Graph;
• add vertex in VertexList should create a new Vertex object and add it to the vertex list.
It should do nothing if a vertex with that name already is present in the list.
• add arc should insert to in from’s adjacency list. It should start with inserting from and
to in the vertex list — in that way arcs and vertices may be added in arbitrary order.
• find is used in add vertex and in insert.
• The VertexList destructor is quite difficult to write correctly, since you have to be careful
so no Vertex object is deleted more than once. It is easiest to start by removing pointers
from the adjacency lists so the graph isn’t circular, before deleting the objects. — You may
treat the destructor as optional, if you wish.
• Advice: draw your own picture of a graph structure, with all objects, vptrs and pointers.
A7. The classes are in the files vertex.h, vertex.cc, vertexlist.h, vertexlist.cc, graph.h. Implement
the classes, except top sort and dfs visit, and test using the program graph test.cc.
Comment out the lines in the function testGraph that check the top sort algorithm.
4.3 Topological Sort
A topological ordering of the vertices of a graph is essentially obtained by a depth-first search
from all vertices. (There are other algorithms for topological sorting. If you prefer another
algorithm you are free to use that one instead.) The topological ordering is not necessarily unique.
For instance, the vertices of the graph in the preceding section may be ordered like this:
A C B D E or
C A D B E or . . .
The algorithm is described below, in pseudo-code. The algorithm produces the vertices in reverse
topological order, which is why we use a stack for the result.