分配结构列表的向量

Question

I have a class that has a member which is a vector of lists of structs and I want to dynamically allocate the lists and the elements inside the lists. I'm not sure why, but for some reason my lists seem to be empty even though I'm adding the elements.

Here is the code:

#include <iostream>
#include <vector>
#include <list>

using namespace std;

template <class Weight>
class Graph {
private:
    struct Edge {
        int node;
        Weight weight;
    };

    vector<list<Edge>> nodes;
public:
    Graph(int numberOfNodes) {
        int i;
        for (i=0; i < numberOfNodes; ++i) {
            nodes.push_back(*(new list<Edge>));
        }
    }

    void addEdge(int nodeA, int nodeB, Weight weight, bool bothWays= false) {
        if (bothWays) {
            addEdge(nodeB, nodeA, weight);
        }
        list<Edge> edgesA= nodes.at(nodeA);
        Edge *edge= new Edge;
        edge->node = nodeB;
        edge->weight = weight;
        edgesA.push_back(*edge);
    }


    void print() {
        unsigned int i;
        list<Edge> edges;
        for(i=0; i < nodes.size(); ++i) {
            cout << "Node " << i << ". Edges: ";
            edges= nodes.at(i);
            typename list<Edge>::iterator iterator = edges.begin();
            typename list<Edge>::iterator end = edges.end();
            for (; iterator != end; ++iterator) {
                cout << "Node " << iterator->node << ". Weight: " << iterator->weight;
            }
            cout << endl;
        }
    }
};


Graph<int> generateRandomGraph(int numberOfNodes) {
    Graph<int> g(numberOfNodes);
    int i, j, weight=22;
    for(i=0; i < numberOfNodes; ++i) {
        for(j=i; j < numberOfNodes; j++) {
            g.addEdge(i, j, weight, true);
        }
    }
    return g;
}


int main() {
    Graph<int> g= generateRandomGraph(3);
    g.print();
}

It is printing this:

Node 0. Edges: 
Node 1. Edges: 
Node 2. Edges: 

As if the lists were empty. tried to use the debugged to find out what is wrong but with no luck. I come from an ANSI C background and I'm still not sure how the new keyword works. Should I store a pointer to the list inside my vector? Should I store a pointer to my struct inside my list?

Also if the answer could also provide how to deallocate the memory on the destructor of the class I would really appreciate it.

Note: the template is so that the weights on my Graph can be defined as int or float.

EDIT: I just want to add that I was not using any hard-coded pointers before. The code you see here is what I got after a few hours of trial and error to get it to work.

Answer 1

As noted in the comments, there are a number of issues with memory management here, but the reason the list of edges is remaining empty is the code in addEdge(...) .

If you change it to this:

void addEdge(int nodeA, int nodeB, Weight weight, bool bothWays= false) {
    if (bothWays) {
        addEdge(nodeB, nodeA, weight);
    }
    Edge edge;
    edge.node = nodeB;
    edge.weight = weight;
    nodes.at(nodeA).push_back(edge);
}

You will get rid of one of the memory management issues, and also have a list of edges. For clarity, the previous code was making a copy of the list of edges, and adding the new edge to the copy, rather than the original list.

The other memory management issue that I can see is in the constructor. Here is a transliteration without the memory management problem. There are other ways to do this using the resize(...) method on vector that involve less code (left as an exercise):

Graph(int numberOfNodes) {
    int i;
    for (i=0; i < numberOfNodes; ++i) {
        nodes.push_back(list<Edge>());
    }
}

There are a couple of other things that I would do differently, but you might want to take this to codereview.stackexchange.com for a complete review.

Answer 2

Graph(int numberOfNodes) 
{
    int i;
    for (i=0; i < numberOfNodes; ++i) 
    {
        //nodes.push_back(*(new list<Edge>));
                            ^^^^^^^^^^^^^^ memory leak
       nodes.push_back(list<Edge>()); // adds an empty list to the vector
    }
}

That fixes memory leak #1.

list<Edge> edgesA= nodes.at(nodeA);
Edge *edge= new Edge;
edge->node = nodeB;
edge->weight = weight;
edgesA.push_back(*edge);
                 ^^^^^ memory leak

To fix it:

list<Edge> edgesA= nodes.at(nodeA);
Edge edge; // no need for heap allocation!
edge.node = nodeB;
edge.weight = weight;
edgesA.push_back(edge);

iterator is a terrible name for an iterator variable name.

void print() 
{
    std::for_each(nodes.begin(), nodes.end(), [](const list<Edge>& l)
    {
        std::for_each(l.begin(), l.end(), [](const Edge& e)
        {
            std::cout << "Node " << e.node << ". Weight: " << e.weight;
        });
        std::cout << std::endl;
    });
}

That should fix your output.

You also are operating on a copy of the list instead of the actual list:

list<Edge> edgesA= nodes.at(nodeA);

You should declare it as:

list<Edge>& edgesA= nodes.at(nodeA);
//        ^^ This makes it a reference instead of a copy