boost bgl write_graphviz VertexPropertyWriter和EdgePropertyWriter

Question

Hi any one spot following codes, make_edge_writer function fails to deduce type in gcc4.9. My code is based on following answer found here How to print a graph in graphviz with multiple properties displayed .

#include <boost/graph/graphviz.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <string>
#include <tuple>
#include <iostream>
#include <iomanip>
#include <map>
#include <random>
#include <cmath>
#include <fstream>
#include <utility>
#include <boost/graph/iteration_macros.hpp>
#include <boost/graph/graph_utility.hpp>
using namespace boost;

struct vert{
    std::string name;
};

struct edge{
    int capacity;
    int weight;
}; 

template <class WeightMap,class CapacityMap>
class edge_writer
{
    public:
    edge_writer(WeightMap w, CapacityMap c) : wm(w),cm(c) {}

    template <class Edge>
    void operator()(ostream &out, const Edge& e) const {
        out << "[label=\"" << wm[e] << "\", taillabel=\"" << cm[e] << "\"]";
    }
    private:
    WeightMap wm;
    CapacityMap cm;
};

template <class WeightMap, class CapacityMap>
inline edge_writer<WeightMap,CapacityMap> 
make_edge_writer(WeightMap w,CapacityMap c)
{
    return edge_writer<WeightMap,CapacityMap>(w,c);
}

int main(int a,char **b)
{
    typedef adjacency_list<listS, vecS, undirectedS, vert, edge> Graph;
    Graph g;
    vector<int,int> ele;
    edge prop;
    prop.weight = 5;
    prop.capacity = 4;
    add_edge(ele.first,ele.second, prop, g);
    std::random_device rd;
// Choose a random mean between 1 and 100
    std::default_random_engine e1(rd());
    std::uniform_int_distribution<int> uniform_dist(1, 100);
    for (int a=0;a<20;++a){
        edge prop1;
        prop1.weight = uniform_dist(e1);
        prop1.capacity = uniform_dist(e1); 
        add_edge(ele.first,ele.second, prop1, g);
    }
    std::ofstream dot("graph.dot");
    write_graphviz(
        dot,
        g,
        boost::make_label_writer(
            boost::get(&vert::name, g)
        ),
        make_edge_writer(
            boost::get(&edge::weight,g),
            boost::get(&edge::capacity,g)
        )
    );
}

Answer 1

You had the syntax problems mentioned in the comment, and were inserting all edges with the same uninitialized source and target fro ele (which was supposed to be a std::pair<int, int> ?).

Generating random graphs... the easy way

If you're into generating random graphs, you can use boost::generate_random_graph :

int main() {
    typedef b::adjacency_list<b::listS, b::vecS, b::undirectedS, vert, edge> Graph;
    Graph g;

    b::generate_random_graph(g, 10 /*100*/, 5 /*20*/, rng);

    std::ofstream dot("graph.dot");
    write_graphviz(dot, g, boost::make_label_writer(boost::get(&vert::name, g)),
                make_edge_writer(boost::get(&edge::weight, g), boost::get(&edge::capacity, g)));
}

For simplicity I used in-class initializers to generate random weights/capacities:

struct edge {
    int capacity = uniform_dist(rng);
    int weight   = uniform_dist(rng);
};

See it Live On Coliru

Eg

or