Confusion in creating a directed graph in C++ - c++

Question

I am trying to create a directed graph by reading a text file where each line has two columns, first column is a tail vertex and second column is the head vertex. Presently just to test if my code works I am trying to populate the graph and print it out.
I am printing my graph after every node insertion. Graph print works as fine until I insert the third node "4" after which first node changes to 0 from 1. I do not have any clue why. I wonder if storing node pointers in edge is a good idea. I am doing it because I already have node information in the "nodes" vector hence do not want to duplicate it.
Input test file:
1 2
4 5
My data structures are:
node: which holds node id and and boolean variable node dirty
edge: which holds pointers to tail node and head node
graph: Holds vectors of all nodes and edges
Output:
Pushing :1
print called
Nodes are:
1
Pushing :2
print called
Nodes are:
1
2
Pushing :4
print called
0(0) --> 2(0) // Problem this should have been 1(0) --> 2(0)
Nodes are:
1
2
4
#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;
class node {
public:
node() {}
node(int _nodeId, bool dirty);
int nodeId;
bool dirty;
void operator=(node rhs);
bool operator==(node rhs);
};
class edge {
public:
edge(node *_startNode, node *_endNode): startNode(_startNode), endNode(_endNode) {}
node *startNode, *endNode;
};
node :: node(int _nodeId, bool _dirty) {
nodeId = _nodeId;
dirty = _dirty;
}
void node :: operator=(node rhs) {
this->dirty = rhs.dirty;
this->nodeId = rhs.nodeId;
}
bool node :: operator==(node rhs) {
if (this->nodeId == rhs.nodeId) {
return true;
}
return false;
}
class graph {
public:
void print();
void addEdge(node startNode, node endNode);
void addNode(node n);
void dfs(node s);
private:
vector<edge> edges;
vector<node> nodes;
};
void graph :: addNode(node n) {
// only add this node if it does not exist in the graph
if (find(nodes.begin(), nodes.end(), n) == nodes.end()) {
//print();
cout << "Pushing :"<<n.nodeId<<endl;
nodes.push_back(n);
}
print();
cout << endl;
}
void graph :: dfs(node s) {
// Search node s and mark it as dirty
}
void graph :: print() {
cout << "print called\n";
vector<edge>::iterator itr = edges.begin();
while (itr != edges.end()) {
cout << itr->startNode->nodeId << "("<< itr->startNode->dirty<<") --> ";
cout << itr->endNode->nodeId << "("<< itr->endNode->dirty<<")"<<endl;
++itr;
}
cout << "Nodes are:\n";
for (int i=0; i< nodes.size(); ++i) {
cout << nodes.at(i).nodeId << endl;
}
}
void graph :: addEdge(node startNode, node endNode) {
vector<node>::iterator itrStartNode;
itrStartNode = find(nodes.begin(), nodes.end(), startNode);
vector<node>::iterator itrEndNode;
itrEndNode = find(nodes.begin(), nodes.end(), endNode);
edge e(&(*itrStartNode), &(*itrEndNode));
edges.push_back(e);
}
int main(int argc, char *argv[]) {
graph g;
// Read the file here
ifstream file;
file.open("test.txt", ios::in);
string line;
while (getline(file, line)) {
int startNodeId, endNodeId;
istringstream is(line);
is >> startNodeId >> endNodeId;
node startNode(startNodeId, false);
node endNode(endNodeId, false);
g.addNode(startNode);
g.addNode(endNode);
g.addEdge(startNode, endNode);
}
file.close();
g.print();
return 0;
}

Answer 1

You're creating temporary variables, e.g.
node startNode(startNodeId, false);
node endNode(endNodeId, false);
and
edge e(&(*itrStartNode), &(*itrEndNode));
and storing pointers to temporary instances into your containers, e.g.
edge e(&(*itrStartNode), &(*itrEndNode));
edges.push_back(e);
Once you exit the local scope in which those instances were created (the while loop or the addEdge method), the stack memory storing those instances are taken back by the program for use elsewhere. However, your pointers still point to valid memory addresses (taken back by the program or not), and so, may still point to valid-seeming data. That's probably what's going on, i.e. why you're seeing valid-seeming but incorrect vertices.
Use the new operator to create instances that persist beyond the local scopes of loops and functions, and clean them up (via delete) appropriately.