copie bords graphique BOOST C++

Question

Je suis en train de faire un programme qui a lu des graphiques à partir du fichier txt (quelque chose comme http://pastebin.com/g4cgaHJB), puis createand les mettre dans un vecteur. (Ce travail partiel parfaitement)

here ise the code: 
#include <iostream> 
#include <vector> 
#include <ctime> 
#include <set> 
#include <fstream> 
#include <string> 
#include <unordered_set> 
#include <cstdlib> 
#include <boost/algorithm/string/split.hpp> 
#include <boost/algorithm/string/classification.hpp> 
#include <boost/graph/adjacency_list.hpp> 
using namespace std; 
using namespace boost; 
using namespace boost::algorithm; 
/*********************************************/ 
//vertex 
struct VertexProperties 
{ 
    int id; 
    int label; 

    VertexProperties(){} 
    VertexProperties(unsigned i, unsigned l) : id(i), label(l) {} 
}; 

//edge 
struct EdgeProperties 
{ 
    unsigned id; 
    unsigned label; 
    EdgeProperties(){} 
    EdgeProperties(unsigned i, unsigned l) : id(i), label(l) {} 
}; 

//Graph 
struct GraphProperties 
{ 
    unsigned id; 
    unsigned label; 
    GraphProperties() {} 
    GraphProperties(unsigned i, unsigned l) : id(i), label(l) {} 
}; 


//adjency list 
typedef boost::adjacency_list< 
    boost::vecS, boost::vecS, boost::directedS, 
    VertexProperties, 
    EdgeProperties, 
    GraphProperties 
> Graph; 


//descriptors 
typedef boost::graph_traits<Graph>::vertex_descriptor vertex_t; 
typedef std::pair<boost::graph_traits<Graph>::edge_descriptor, bool> edge_t; 
//iterators 
typedef graph_traits<Graph>::vertex_iterator vertex_iter; 
typedef graph_traits<Graph>::edge_iterator edge_iter; 
/****************************************************************************/ 
//le seuil int seuil; 
std::vector<std::string> tokens; 

/* 
    programme principal 
*/ 
int main() 
{ 
    vector<Graph> dataG; // vector<graphes> * pointsdataG; 

    ifstream * file_reader= new ifstream("5.txt"); //flux d'entrée pour opérer sur les fichiers. 

    while (!file_reader->eof()) 
     { 
     string line; 

     file_reader->sync();//Synchronize input buffer 

     getline(*file_reader, line);//getline reads characters from an input stream and places them into a string 
     std::stringstream ss(line); //use a string buffer that contains a sequence of characters. 
     char lineType; 
     ss >> lineType; 
     if(lineType =='t') 
     { 
      char diez; 
      int gid; 
      ss >> diez >> gid; 
      Graph g(GraphProperties(gid,gid)); 
      dataG.push_back(g); 
     } else if (lineType == 'v') 
     { 
      assert(!dataG.empty());//evaluate the parameter. If this parameter is false it causes an assertion failure that terminates the program. 
      int vId, vLabel; 
      ss >> vId >> vLabel; 
      boost::add_vertex(VertexProperties(vId, vLabel), dataG[dataG.size()-1]); 
     } else if (lineType == 'e') 
     { 
      assert(!dataG.empty()); 
      int fromId, toId, vLabel; 
      ss >> fromId >> toId >> vLabel; 

      // Note that the EdgeProperty.id doesn't make sense with your input data 
      // as it only contains [vertexFrom vertexTo edgeData] 
      boost::add_edge(fromId, toId, 
          EdgeProperties(vLabel, vLabel), dataG[dataG.size()-1]); 
     } 
     } 


     cout<<"fin."<<endl; // fin du programme. 

     return 0; 
} 

Idée: Je suis en train de itereate sur les graphes, en partant du premier bord (et créer un graphique de celui-ci permet de l'appeler testg), et tester si ce graphique est fréquent (je vais tester sous-graphe -isomorphisme entre testg et chaque graphique dans le vecteur dataG puis je compter combien de temps il est vrai s'il y a beaucoup de temps alors 2 si testg est fréquent), si testg est fréquente donc je vais y ajouter une autre bord adjacent (et faire le test-sous-graphe isomorpshism à nouveau), si testg est plus fréquente j'ôterai le dernier front ajouté (backtrack) et le changer par un autre (et faire le test-sous-graphe isomorpshism à nouveau). s'il n'y a plus de bord à ajouter, je dirai que testg est fermé. et le mettre dans un vecteur permet de l'appeler ferméG.

j'ai commencé l'idée en faisant ceci:

auto gr=dataG.at(0); 
     Graph testg();    
     edge_pair ep; 

     for (ep = edges(gr); ep.first != ep.second; ++ep.first) //ep edge number 
     { 
      vertex_t from = source(*ep.first, gr); 
      vertex_t to = target(*ep.first, gr); 
      edge_t edg = edge(from, to, gr); 
      boost::add_edge(from, to,testg); 
     } 

Mais, cela ne fonctionne pas! voici les erreurs:

In function 'int main()' 
:workshop.cpp:123:42: error: no matching function for call to 'add_edge(vertex_t&, vertex_t&, Graph (&)())'boost: 
:add_edge(from, to, testg); 
workshop.cpp:123:42: note: candidates are 
:In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:707:5: note: template<class Config> std::pair<typename boost::directed_graph_helper<Config>::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor, const typename Config::edge_property_type&, boost::directed_graph_helper<Config>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:707:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: candidate expects 4 arguments, 3 providedboost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:727:5: note: template<class Config> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor, boost::directed_graph_helper<Config>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:727:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: mismatched types 'boost::directed_graph_helper<Config>' and 'Graph() {aka boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS, VertexProperties, EdgeProperties, GraphProperties>()}'boost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:1045:5: note: template<class Config> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor, const typename Config::edge_property_type&, boost::undirected_graph_helper<C>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:1045:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: candidate expects 4 arguments, 3 providedboost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:1075:5: note: template<class Config> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor, boost::undirected_graph_helper<C>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:1075:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: mismatched types 'boost::undirected_graph_helper<C>' and 'Graph() {aka boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS, VertexProperties, EdgeProperties, GraphProperties>()}'boost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:1473:5: note: template<class Config> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor, const typename Config::edge_property_type&, boost::bidirectional_graph_helper_with_property<Config>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:1473:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: candidate expects 4 arguments, 3 providedboost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:1503:5: note: template<class Config> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor, boost::bidirectional_graph_helper_with_property<Config>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:1503:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: mismatched types 'boost::bidirectional_graph_helper_with_property<Config>' and 'Graph() {aka boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS, VertexProperties, EdgeProperties, GraphProperties>()}'boost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:2217:5: note: template<class Graph, class Config, class Base> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor,const typename Config::edge_property_type&, boost::vec_adj_list_impl<G, C, B>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:2217:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: candidate expects 4 arguments, 3 providedboost: 
:add_edge(from, to, testg); 
In file included from ./boost/graph/adjacency_list.hpp:246:0,from workshop.cpp:12 
:./boost/graph/detail/adjacency_list.hpp:2231:5: note: template<class Graph, class Config, class Base> std::pair<typename Config::edge_descriptor, bool> boost::add_edge(typename Config::vertex_descriptor, typename Config::vertex_descriptor,boost::vec_adj_list_impl<G, C, B>&)add_edge(typename Config: 
:vertex_descriptor u, 
./boost/graph/detail/adjacency_list.hpp:2231:5: note: template argument deduction/substitution failed 
:workshop.cpp:123:42: note: mismatched types 'boost::vec_adj_list_impl<G, C, B>' and 'Graph() {aka boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS, VertexProperties, EdgeProperties, GraphProperties>()}'boost::add_edge(from, to, testg); 

Answer 1

Vous avez tomber victime de la most vexing parse:

Graph testg(); 

Déclare une fonction. Ne te sens pas mal. Il m'a fallu du temps pour voir ça. oO

Il suffit d'écrire

Graph testg; 

ou si vous voulez quelque chose qui est presque toujours ce que vous entendez:

Graph testg {}; 

Ne vous sentez mal à

• il using namespace (surtout depuis std et boostdo introduisons conflits importants),
• redondant comprend
• utilisation gratuite de new pour le flux de fichiers ...
• mauvaise utilisation de eof() dans une boucle de lecture
• utilisation répétée de dataG[dataG.size() -1] où data.back() pourrait être utilisé
• absence d'entrée de traitement d'erreur d'analyse
• rétrécissement de gid (int) à unsigned int

Live On Coliru

#include <boost/graph/adjacency_list.hpp> 
#include <fstream> 
#include <iostream> 
#include <string> 
#include <vector> 

using namespace boost; 

/*********************************************/ 
// vertex 
struct VertexProperties { 
    int id; 
    int label; 
    VertexProperties(unsigned i=0, unsigned l=0) : id(i), label(l) {} 
}; 

// edge 
struct EdgeProperties { 
    unsigned id; 
    unsigned label; 
    EdgeProperties(unsigned i=0, unsigned l=0) : id(i), label(l) {} 
}; 

// Graph 
struct GraphProperties { 
    unsigned id; 
    unsigned label; 
    GraphProperties(unsigned i=0, unsigned l=0) : id(i), label(l) {} 
}; 

// adjency list 
typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS, 
     VertexProperties, 
     EdgeProperties, 
     GraphProperties> Graph; 

// descriptors 
typedef boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor; 
typedef std::pair<boost::graph_traits<Graph>::edge_descriptor, bool> edge_t; 
// iterators 
typedef graph_traits<Graph>::vertex_iterator vertex_iter; 
typedef graph_traits<Graph>::edge_iterator edge_iter; 

int main() { 
    std::vector<Graph> dataG; 

    std::ifstream file_reader("5.txt"); // flux d'entrée pour opérer sur les fichiers. 

    std::string line; 
    while (std::getline(file_reader, line)) { // getline reads characters from an input stream and places them into a string 

     char lineType; 

     std::stringstream ss(line); // use a string buffer that contains a sequence of characters. 
     if (ss >> lineType) switch (lineType) { 
      case 't': 
       { 
        char diez; 
        unsigned gid; 
        if (ss >> diez >> gid) { 
         dataG.emplace_back(GraphProperties { gid, gid }); 
        } 
        else throw std::runtime_error("Error parsing '" + line + "'"); 
       } 
       break; 
      case 'v': 
       { 
        assert(!dataG.empty()); 

        int vId, vLabel; 
        if (ss >> vId >> vLabel) { 
         boost::add_vertex(VertexProperties(vId, vLabel), dataG.back()); 
        } 
        else throw std::runtime_error("Error parsing '" + line + "'"); 
       } 
       break; 
      case 'e': 
       { 
        assert(!dataG.empty()); 

        int fromId, toId, vLabel; 
        if (ss >> fromId >> toId >> vLabel) { 
         // Note that the EdgeProperty.id doesn't make sense with your input data 
         // as it only contains [vertexFrom vertexTo edgeData] 
         boost::add_edge(fromId, toId, EdgeProperties(vLabel, vLabel), dataG.back()); 
        } 
        else throw std::runtime_error("Error parsing '" + line + "'"); 
       } 
       break; 
     } else 
     { 
      // ignoring empty line 
     } 
    } 

    if (!dataG.empty()) { 
     auto const& gr = dataG.front(); // no copy 
     Graph testg; 

     for (auto ep = edges(gr); ep.first != ep.second; ++ep.first) // ep edge number 
     { 
      vertex_descriptor from = source(*ep.first, gr); 
      vertex_descriptor to = target(*ep.first, gr); 

      boost::add_edge(from, to, testg); 
     } 
    } 
    std::cout << "fin." << std::endl; // fin du programme. 
}