la difference entre deux std::vector

Version imprimable

onjour !!! j'utilise BOOST pour un probléme de graphe mining.
le programme complet se trouve ici : http://pastebin.com/8NejJvcx

Je voulais faire une fonction qui a comme arguments deux graphes et qui retourne un vector , ce vector contient la difference entre les aretes des deux graphes.
voila ce que j'ai fais jusqu’à maintenant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 std::vector<edge_iter> edgesdiff(Graph const& g1,Graph const& g2){ std::vector<edge_iter> v1; std::vector<edge_iter> v2; std::vector<edge_iter> result; typedef graph_traits<Graph>::edge_iterator edge_iter; std::pair<edge_iter, edge_iter> ep; edge_iter ei, ei_end; for (tie(ei, ei_end) = edges(g1); ei != ei_end; ++ei){v1.push_back(ei);} for (tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei){v2.push_back(ei);} /* d i f f e r e n c e*/ return result; }
il manque la partie /* d i f f e r e n c e*/ ou je veux faire la difference entre v1 et v2 et l'inserer dans result.
Par difference je veux dire les elements qui sont dans v1 et ne sont pas dans v2 et vice-versa.

Aidez moi a compléter le programme svp!

25/03/2015, 10h01
ternel

Quand on a un problème d'algorithme, on regarde ce que propose <algorithm>.

Tu veux la différence entre deux ensembles de valeurs.
Ca tombe bien, il y a ce qu'il faut: set_symmetric_difference.

Citation:

Envoyé par leternel

Quand on a un problème d'algorithme, on regarde ce que propose <algorithm>.

Tu veux la différence entre deux ensembles de valeurs.
Ca tombe bien, il y a ce qu'il faut: set_symmetric_difference.

voila ce que j'ai fais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
std::vector<edge_iter> edgesdiff(Graph const& g1,Graph const& g2){
 
std::vector<edge_iter> v1;
std::vector<edge_iter> v2;
std::vector<edge_iter> result;
 
typedef graph_traits<Graph>::edge_iterator edge_iter;
std::pair<edge_iter, edge_iter> ep;
 
edge_iter ei, ei_end;
for (tie(ei, ei_end) = edges(g1); ei != ei_end; ++ei){v1.push_back(ei);}
for (tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei){v2.push_back(ei);}
 
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
 
/*
    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(result));
 
*/
return result;
}

mais ça me donne des erreurs du type:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp||In function ‘void emptygraphaddedge(Graph&, std::vector<boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties> >)’:|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|308|warning: operation on ‘cpt’ may be undefined [-Wsequence-point]|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|308|warning: operation on ‘cpt’ may be undefined [-Wsequence-point]|
/usr/include/boost/iterator/iterator_adaptor.hpp||In instantiation of ‘typename boost::detail::iterator_adaptor_base<Derived, Base, Value, Traversal, Reference, Difference>::type::difference_type boost::iterator_adaptor<Derived, Base, Value, Traversal, Reference, Difference>::distance_to(const boost::iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D>&) const [with OtherDerived = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; OtherIterator = std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >; V = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; C = boost::use_default; R = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; D = int; Derived = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; Base = std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >; Value = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Traversal = boost::use_default; Reference = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Difference = int; typename boost::detail::iterator_adaptor_base<Derived, Base, Value, Traversal, Reference, Difference>::type::difference_type = int]’:|
/usr/include/boost/iterator/iterator_facade.hpp|551|required from ‘static typename Facade1::difference_type boost::iterator_core_access::distance_from(const Facade1&, const Facade2&, mpl_::true_) [with Facade1 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; Facade2 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; typename Facade1::difference_type = int; mpl_::true_ = mpl_::bool_<true>]’|
/usr/include/boost/iterator/iterator_facade.hpp|835|required from ‘typename boost::detail::enable_if_interoperable<Derived1, Derived2, typename boost::mpl::apply2<boost::detail::always_bool2, Derived1, Derived2>::type>::type boost::operator<(const boost::iterator_facade<Derived1, V1, TC1, Reference1, Difference1>&, const boost::iterator_facade<Derived2, V2, TC2, Reference2, Difference2>&) [with Derived1 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; V1 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; TC1 = boost::bidirectional_traversal_tag; Reference1 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Difference1 = int; Derived2 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; V2 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; TC2 = boost::bidirectional_traversal_tag; Reference2 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Difference2 = int; typename boost::detail::enable_if_interoperable<Derived1, Derived2, typename boost::mpl::apply2<boost::detail::always_bool2, Derived1, Derived2>::type>::type = bool]’|
/usr/include/c++/4.9/bits/predefined_ops.h|42|required from ‘bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Iterator2 = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >]’|
/usr/include/c++/4.9/bits/stl_algo.h|1846|required from ‘void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]’|
/usr/include/c++/4.9/bits/stl_algo.h|1884|required from ‘void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]’|
/usr/include/c++/4.9/bits/stl_algo.h|1970|required from ‘void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]’|
/usr/include/c++/4.9/bits/stl_algo.h|4685|required from ‘void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >]’|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|368|required from here|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|error: no match for ‘operator-’ (operand types are ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ and ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’)|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note: candidates are:|
/usr/include/boost/iterator/iterator_facade.hpp|842|note: template<class Derived1, class V1, class TC1, class Reference1, class Difference1, class Derived2, class V2, class TC2, class Reference2, class Difference2> typename boost::detail::enable_if_interoperable<Derived1, Derived2, typename boost::mpl::apply2<boost::detail::choose_difference_type, Derived1, Derived2>::type>::type boost::operator-(const boost::iterator_facade<Derived1, V1, TC1, Reference1, Difference1>&, const boost::iterator_facade<Derived2, V2, TC2, Reference2, Difference2>&)|
/usr/include/boost/iterator/iterator_facade.hpp|842|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const boost::iterator_facade<Derived1, V1, TC1, Reference1, Difference1>’|
/usr/include/boost/concept_archetype.hpp|314|note: template<class Base> boost::subtractable_archetype<Base> boost::operator-(const boost::subtractable_archetype<Base>&, const boost::subtractable_archetype<Base>&)|
/usr/include/boost/concept_archetype.hpp|314|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const boost::subtractable_archetype<Base>’|
/usr/include/boost/concept_archetype.hpp|345|note: template<class Return, class BaseFirst, class BaseSecond> Return boost::operator-(const boost::subtract_op_first_archetype<Return, BaseFirst>&, const boost::subtract_op_second_archetype<Return, BaseSecond>&)|
/usr/include/boost/concept_archetype.hpp|345|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const boost::subtract_op_first_archetype<Return, BaseFirst>’|
/usr/include/c++/4.9/complex|446|note: template<class _Tp> std::complex<_Tp> std::operator-(const std::complex<_Tp>&)|
/usr/include/c++/4.9/complex|446|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::complex<_Tp>’|
/usr/include/c++/4.9/complex|369|note: template<class _Tp> std::complex<_Tp> std::operator-(const _Tp&, const std::complex<_Tp>&)|
/usr/include/c++/4.9/complex|369|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::complex<_Tp>’|
/usr/include/c++/4.9/complex|360|note: template<class _Tp> std::complex<_Tp> std::operator-(const std::complex<_Tp>&, const _Tp&)|
/usr/include/c++/4.9/complex|360|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::complex<_Tp>’|
/usr/include/c++/4.9/complex|351|note: template<class _Tp> std::complex<_Tp> std::operator-(const std::complex<_Tp>&, const std::complex<_Tp>&)|
/usr/include/c++/4.9/complex|351|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::complex<_Tp>’|
/usr/include/c++/4.9/bits/stl_deque.h|347|note: template<class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR> typename std::_Deque_iterator<_Tp, _Ref, _Ptr>::difference_type std::operator-(const std::_Deque_iterator<_Tp, _Ref, _Ptr>&, const std::_Deque_iterator<_Tp, _RefR, _PtrR>&)|
/usr/include/c++/4.9/bits/stl_deque.h|347|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::_Deque_iterator<_Tp, _Ref, _Ptr>’|
/usr/include/c++/4.9/bits/stl_deque.h|335|note: template<class _Tp, class _Ref, class _Ptr> typename std::_Deque_iterator<_Tp, _Ref, _Ptr>::difference_type std::operator-(const std::_Deque_iterator<_Tp, _Ref, _Ptr>&, const std::_Deque_iterator<_Tp, _Ref, _Ptr>&)|
/usr/include/c++/4.9/bits/stl_deque.h|335|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::_Deque_iterator<_Tp, _Ref, _Ptr>’|
/usr/include/c++/4.9/bits/stl_bvector.h|208|note: std::ptrdiff_t std::operator-(const std::_Bit_iterator_base&, const std::_Bit_iterator_base&)|
/usr/include/c++/4.9/bits/stl_bvector.h|208|note:   no known conversion for argument 1 from ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ to ‘const std::_Bit_iterator_base&’|
/usr/include/c++/4.9/bits/stl_iterator.h|1128|note: template<class _Iterator> decltype ((__x.base() - __y.base())) std::operator-(const std::move_iterator<_Iterator>&, const std::move_iterator<_Iterator>&)|
/usr/include/c++/4.9/bits/stl_iterator.h|1128|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::move_iterator<_Iterator>’|
/usr/include/c++/4.9/bits/stl_iterator.h|1121|note: template<class _IteratorL, class _IteratorR> decltype ((__x.base() - __y.base())) std::operator-(const std::move_iterator<_Iterator>&, const std::move_iterator<_IteratorR>&)|
/usr/include/c++/4.9/bits/stl_iterator.h|1121|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::move_iterator<_Iterator>’|
/usr/include/c++/4.9/bits/stl_iterator.h|380|note: template<class _IteratorL, class _IteratorR> decltype ((__y.base() - __x.base())) std::operator-(const std::reverse_iterator<_Iterator>&, const std::reverse_iterator<_IteratorR>&)|
/usr/include/c++/4.9/bits/stl_iterator.h|380|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::reverse_iterator<_Iterator>’|
/usr/include/c++/4.9/bits/stl_iterator.h|328|note: template<class _Iterator> typename std::reverse_iterator<_Iterator>::difference_type std::operator-(const std::reverse_iterator<_Iterator>&, const std::reverse_iterator<_Iterator>&)|
/usr/include/c++/4.9/bits/stl_iterator.h|328|note:   template argument deduction/substitution failed:|
/usr/include/boost/iterator/iterator_adaptor.hpp|352|note:   ‘const std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >’ is not derived from ‘const std::reverse_iterator<_Iterator>’|
/usr/include/boost/iterator/iterator_adaptor.hpp||In instantiation of ‘void boost::detail::iterator_adaptor_assert_traversal() [with Tr1 = boost::detail::iterator_category_with_traversal<std::input_iterator_tag, boost::bidirectional_traversal_tag>; Tr2 = boost::random_access_traversal_tag]’:|
/usr/include/boost/iterator/iterator_adaptor.hpp|347|required from ‘typename boost::detail::iterator_adaptor_base<Derived, Base, Value, Traversal, Reference, Difference>::type::difference_type boost::iterator_adaptor<Derived, Base, Value, Traversal, Reference, Difference>::distance_to(const boost::iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D>&) const [with OtherDerived = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; OtherIterator = std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >; V = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; C = boost::use_default; R = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; D = int; Derived = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; Base = std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >; Value = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Traversal = boost::use_default; Reference = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Difference = int; typename boost::detail::iterator_adaptor_base<Derived, Base, Value, Traversal, Reference, Difference>::type::difference_type = int]’|
/usr/include/boost/iterator/iterator_facade.hpp|551|required from ‘static typename Facade1::difference_type boost::iterator_core_access::distance_from(const Facade1&, const Facade2&, mpl_::true_) [with Facade1 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; Facade2 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; typename Facade1::difference_type = int; mpl_::true_ = mpl_::bool_<true>]’|
/usr/include/boost/iterator/iterator_facade.hpp|835|required from ‘typename boost::detail::enable_if_interoperable<Derived1, Derived2, typename boost::mpl::apply2<boost::detail::always_bool2, Derived1, Derived2>::type>::type boost::operator<(const boost::iterator_facade<Derived1, V1, TC1, Reference1, Difference1>&, const boost::iterator_facade<Derived2, V2, TC2, Reference2, Difference2>&) [with Derived1 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; V1 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; TC1 = boost::bidirectional_traversal_tag; Reference1 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Difference1 = int; Derived2 = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; V2 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; TC2 = boost::bidirectional_traversal_tag; Reference2 = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; Difference2 = int; typename boost::detail::enable_if_interoperable<Derived1, Derived2, typename boost::mpl::apply2<boost::detail::always_bool2, Derived1, Derived2>::type>::type = bool]’|
/usr/include/c++/4.9/bits/predefined_ops.h|42|required from ‘bool __gnu_cxx::__ops::_Iter_less_iter::operator()(_Iterator1, _Iterator2) const [with _Iterator1 = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Iterator2 = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >]’|
/usr/include/c++/4.9/bits/stl_algo.h|1846|required from ‘void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]’|
/usr/include/c++/4.9/bits/stl_algo.h|1884|required from ‘void std::__final_insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]’|
/usr/include/c++/4.9/bits/stl_algo.h|1970|required from ‘void std::__sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >; _Compare = __gnu_cxx::__ops::_Iter_less_iter]’|
/usr/include/c++/4.9/bits/stl_algo.h|4685|required from ‘void std::sort(_RAIter, _RAIter) [with _RAIter = __gnu_cxx::__normal_iterator<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>*, std::vector<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int> > >]’|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|368|required from here|
/usr/include/boost/iterator/iterator_adaptor.hpp|224|error: static assertion failed: (is_convertible<Tr1, Tr2>::value)|
||=== Build failed: 2 error(s), 21 warning(s) (0 minute(s), 6 second(s)) ===|

25/03/2015, 13h39
stendhal666

C'est toujours la galère de s'y retrouver dans les messages d'erreur du compilateur. Cela étant, il y a toujours ce problème dans ton code que tu mets des itérateurs, pas des valeurs dans les vecteurs.
Or je ne pense pas qu'il soit possible de trier des itérateurs de graphe: en particulier iterator1 < iterator2 ne compile que pour des random_access_iterator
25/03/2015, 13h48
ternel

à moins d'utiliser la seconde forme de la fonction, qui prend un comparateur en argument.
par exemple [](edge_iter const& a, edge_iter const& b) {return *a<*b;}
25/03/2015, 14h10
mohsenuss91

Citation:

Envoyé par stendhal666

C'est toujours la galère de s'y retrouver dans les messages d'erreur du compilateur. Cela étant, il y a toujours ce problème dans ton code que tu mets des itérateurs, pas des valeurs dans les vecteurs.
Or je ne pense pas qu'il soit possible de trier des itérateurs de graphe: en particulier iterator1 < iterator2 ne compile que pour des random_access_iterator

comment dois je faire pour mettre des valeurs au lieux des littérateurs svp!
25/03/2015, 14h19
ternel

Avec un vecteur de edge, plutot qu'un vecteur de edge_iterator, peut-être?
25/03/2015, 15h39
stendhal666
Citation:

comment dois je faire pour mettre des valeurs au lieux des littérateurs svp!

Il faut déréférencer un itérateur pour obtenir la valeur sur laquelle il pointe, avec l'opérateur *:

edge_iterator eit = ...
Edge e = *eit;

Donc pour ton programme, comme dit Leternel:
Code:

1 2 3 std::vector<Edge> model; //tie(b, e); etc. std::for_each(b, e, [a](const edge_iterator& it) {model.push_back(*it); });

Citation:

Envoyé par stendhal666

Il faut déréférencer un itérateur pour obtenir la valeur sur laquelle il pointe, avec l'opérateur *:

edge_iterator eit = ...
Edge e = *eit;

Donc pour ton programme, comme dit Leternel:

Code:

1
2
3
std::vector<Edge> model;
//tie(b, e); etc.
std::for_each(b, e, [a](const edge_iterator& it) {model.push_back(*it); });

Voila ce que j'ai fais:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
template <typename Graph, typename E = typename boost::graph_traits<Graph>::edge_descriptor>
std::vector<E> edgesdiff(Graph const& g1,Graph const& g2){
 
std::vector<E> v1;
std::vector<E> v2;
std::vector<E> result;
tie(ei, ei_end) = edges(g1);
std::for_each(ei, ei_end, [a](const edge_iterator& it) {model.push_back(*it); });
/*
typedef graph_traits<Graph>::edge_iterator edge_iter;
std::pair<edge_iter, edge_iter> ep;
 
edge_iter ei, ei_end;
for (tie(ei, ei_end) = edges(g1); ei != ei_end; ++ei){v1.push_back(ei);}
for (tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei){v2.push_back(ei);}
 
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
 
 
    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(result));
 
*/
return result;
}

mais ça dit que:

Code:

‘ei’ was not declared in this scope|

25/03/2015, 21h17
stendhal666

Eh bien c'est normal, il faut que tu déclares préalablement ei et ei_end:
edge_iterator ei, ei_end;
tie(ei, ei_end) = etc.

Citation:

Envoyé par stendhal666

Eh bien c'est normal, il faut que tu déclares préalablement ei et ei_end:
edge_iterator ei, ei_end;
tie(ei, ei_end) = etc.

voila la dernière mise a jour:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
template <typename Graph, typename E = typename boost::graph_traits<Graph>::edge_descriptor>
std::vector<E> edgesdiff(Graph const& g1,Graph const& g2){
 
std::vector<E> v1;
std::vector<E> v2;
std::vector<E> result;
 
edge_iter ei, ei_end;
tie(ei, ei_end) = edges(g1);
std::for_each(ei, ei_end, [a](const edge_iter& it) {model.push_back(*it); });
/*
typedef graph_traits<Graph>::edge_iterator edge_iter;
std::pair<edge_iter, edge_iter> ep;
 
edge_iter ei, ei_end;
for (tie(ei, ei_end) = edges(g1); ei != ei_end; ++ei){v1.push_back(ei);}
for (tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei){v2.push_back(ei);}
 
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
 
 
    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(result));
 
*/
return result;
}

maintenant ça dit que :

Code:

‘a’ was not declared in this scope

26/03/2015, 10h03
stendhal666

Citation:

std::for_each(ei, ei_end, [a](const edge_iter& it) {model.push_back(*it); });

C'est là qu'est le "a" non déclaré (entre les crochets dans la capture d'environnement: tel que tu l'écris, ça demande au compilateur de capturer par copie un élément 'a' dans le contexte)
Il faut plutôt écrire:

Code:

std::for_each(ei, ei_end, [&](const edge_iter& it) {model.push_back(*it); });
26/03/2015, 10h23
mohsenuss91

Citation:

Envoyé par stendhal666

C'est là qu'est le "a" non déclaré (entre les crochets dans la capture d'environnement: tel que tu l'écris, ça demande au compilateur de capturer par copie un élément 'a' dans le contexte)
Il faut plutôt écrire:

Code:

std::for_each(ei, ei_end, [&](const edge_iter& it) {model.push_back(*it); });

J'ai essayé ça mais :

Code:

error: no match for call to ‘(edgesdiff(const Graph&, const Graph&) [with Graph = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties>; E = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>]::<lambda(const edge_iter&)>) (boost::iterator_facade<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, boost::bidirectional_traversal_tag, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>::reference)’|
26/03/2015, 10h53
ternel

Et normalement, derrière, tu as une liste de fonctions qui aurait pu correspondre.
Sans ca, on ne risque pas de pouvoir t'aider.

Pour lire correctement ce message, je te suggère de le répartir sur plusieurs lignes, et de l'indenter (chaque templatisation étant plus profonde).
26/03/2015, 10h59
stendhal666

je plussoie ce que dit leternel.

Sinon, je me demande où tu définis edge_iter? il faut que le typedef soit dans la fonction template pour qu'il prenne en compte les types en paramètre du template.

Citation:

Envoyé par leternel

Et normalement, derrière, tu as une liste de fonctions qui aurait pu correspondre.
Sans ca, on ne risque pas de pouvoir t'aider.

Pour lire correctement ce message, je te suggère de le répartir sur plusieurs lignes, et de l'indenter (chaque templatisation étant plus profonde).

Voila le code source complet du programme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/vf2_sub_graph_iso.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <ctime>
#include <queue> // std::queue
 
//for mmap:
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
 
using namespace std;
using namespace boost;
 
//==========STRUCTURES==========
// 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::undirectedS, 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;
typedef std::pair<edge_iter, edge_iter> edge_pair;
//=================callback used fro subgraph_iso=================================================================
struct my_callback {
    template <typename CorrespondenceMap1To2, typename CorrespondenceMap2To1>
    bool operator()(CorrespondenceMap1To2 f, CorrespondenceMap2To1 g) const {
        return false;
    }
};
 
//==========handle_error==========
void handle_error(const char *msg) {
    perror(msg);
    exit(255);
}
//============READ ALL THE FILE AND RETURN A STRING===================
const char *readfromfile(const char *fname, size_t &length) {
    int fd = open(fname, O_RDONLY);
    if (fd == -1)
        handle_error("open");
 
    // obtain file size
    struct stat sb;
    if (fstat(fd, &sb) == -1)
        handle_error("fstat");
 
    length = sb.st_size;
 
    const char *addr = static_cast<const char *>(mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0u));
    if (addr == MAP_FAILED)
        handle_error("mmap");
 
    // TODO close fd at some point in time, call munmap(...)
    return addr;
}
//==========SPLIT THE STRING BY NEWLINE (\n) ==========
vector<string> splitstringtolines(string const& str) {
    vector<string> split_vector;
    split(split_vector, str, is_any_of("\n"));
 
    return split_vector;
}
 
//============Get a string starting from pos============
string getpos(int const& pos, string const& yy) {
    size_t i = pos;
    string str;
    for (; yy[i] != ' ' && i < yy.length(); i++)
        str += yy[i];
    return str;
}
//==================read string vector and return graphs vector===================
std::vector<Graph> creategraphs(std::vector<string> const& fichlines) {
    std::vector<Graph> dataG;
    int compide = 0; // compteur de id edge
    for (string yy : fichlines) {
        switch (yy[0]) {
        case 't': {
            string str2 = getpos(4, yy);
            unsigned gid = atoi(str2.c_str());
            dataG.emplace_back(GraphProperties(gid, gid));
            compide = 0;
        } break;
        case 'v': {
            assert(!dataG.empty()); // assert will terminate the program  if its argument turns out to be false
            // cout<<yy<<endl;
            int vId, vLabel;
            string vvv = getpos(2, yy);
            vId = atoi(vvv.c_str());
            string vvvv = getpos((int)vvv.length() + 3, yy);
            // cout<<vvvv<<endl;
            vLabel = atoi(vvvv.c_str());
            boost::add_vertex(VertexProperties(vId, vLabel), dataG.back());
        }
 
        break;
 
        case 'e': { // cout<<yy<<endl;
            assert(!dataG.empty()); // assert will terminate the program  if its argument turns out to be false
 
            int fromId, toId, eLabel;
            string eee = getpos(2, yy);
            // cout<<eee<<endl;
            fromId = atoi(eee.c_str());
            string eee2 = getpos((int)eee.length() + 3, yy);
            // cout<<eee2<<endl;
            toId = atoi(eee2.c_str());
            int c = (int)eee.length() + (int)eee2.length() + 4;
            //    cout<<c<<endl;
            string eee3 = getpos(c, yy);
            //  cout<<eee3<<endl;
            eLabel = atoi(eee3.c_str());
            boost::add_edge(fromId, toId, EdgeProperties(compide, eLabel), dataG.back());
            compide++;
        } break;
        }
    }
 
    return dataG;
}
//============test if the graph is empty========================================================
bool emptygraph(Graph const& g) {
    return ((num_edges(g)==0)&&(num_vertices(g)==0));
}
//============test if the graph connectivity========================================================
bool graphconnexe(Graph const& g) {
    return num_edges(g) >= num_vertices(g) - 1;
}
//====================print the graph information========================================================
void printgraph(Graph const& gr) {
    typedef std::pair<edge_iter, edge_iter> edge_pair;
    std::cout <<"=================================="<<endl;
    std::cout <<" contains " << num_vertices(gr) << " vertices, and " << num_edges(gr) << " edges " << std::endl;
    if (graphconnexe(gr)) {
 
        // Vertex list
        if (num_vertices(gr) != 0) {
            std::cout << "  Vertex list: " << std::endl;
            for (size_t i = 0; i < num_vertices(gr); ++i) // size_t vertice number in the graph
            {
                std::cout << " ID: " << gr[i].id << ", Label: " << gr[i].label << std::endl;
            }
        }
        // Edge list
        if (num_edges(gr) != 0) {
            std::cout << "  Edge list: " << std::endl;
            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);
                std::cout << "   e(" << gr[from].id << "," << gr[to].id << ")   ID: " << gr[edg.first].id
                          << " ,  Label: " << gr[edg.first].label << std::endl;
            }
        }
        std::cout<<endl;
    } else {
        cout << "Please check this graph connectivity." << endl;
    }
}
 
//=================test if the given vertice exist in the graph=========================
bool verticeexist(Graph const& g, int const& vId, int const& vlabel) {
    int cpt = 0;
 
        for (size_t i = 0; i < num_vertices(g); ++i) // size_t vertice number in the graph
        {
            if ((g[i].id == vId) && (g[i].label == vlabel)) {
                cpt++;
            }
        }
 
    return cpt != 0;
}
//======================================================================
bool idverticeexist(Graph const& g, int const& vId) {
    int cpt = 0;
    if (num_edges(g) != 0) {
        for (size_t i = 0; i < num_vertices(g); ++i) // size_t vertice number in the graph
        {
            if (g[i].id == vId) {
                cpt++;
            }
        }
    }
    return cpt != 0;
}
//=======get vertice label label============================
int getvlabel(Graph const& M,int const& id){
int cpt=-1;
 for (size_t i = 0; i < num_vertices(M); ++i){
            if (M[i].id == id) {
                cpt=M[i].label;
            }
        }
 
return cpt;
}
//=============test if the given edge exist in the graph===========================
bool edgeexist(Graph const& g, int const& fromid, int const& toid, unsigned const& elabel) {
    int bn = 0;
    if (graphconnexe(g)) {
        if (num_edges(g) != 0) {
            edge_pair ep;
            for (ep = edges(g); ep.first != ep.second; ++ep.first) // ep edge number
            {
                vertex_t from = source(*ep.first, g);
                vertex_t to = target(*ep.first, g);
                edge_t edg = edge(from, to, g);
 
                if ((g[from].id == fromid) && (g[to].id == toid) && (g[edg.first].label == elabel)) {
                    bn++;
                }
            }
        }
    }
 
    return (bn != 0);
}
 
// =============test if thoses vertices are neighbours============================
bool verticesareneighbours(Graph const& g, int const& a, int const& b) {
    int bn = 0;
    if (graphconnexe(g)) {
 
        if (num_edges(g) != 0) {
            edge_pair ep;
            for (ep = edges(g); ep.first != ep.second; ++ep.first) // ep edge number
            {
                vertex_t from = source(*ep.first, g);
                vertex_t to = target(*ep.first, g);
 
                if (((g[from].id == a) || (g[to].id == a)) && ((g[from].id == b) || (g[to].id == b))) {
                    bn++;
                }
            }
        }
    }
 
    return (bn != 0);
}
//=============test if those edges are neighbours=============================
    template <typename Graph, typename E = typename boost::graph_traits<Graph>::edge_descriptor>
    bool edgesareneighbours(Graph const& g, E e1, E e2) {
 
        std::set<vertex_t> vertex_set {
            source(e1, g), target(e1, g),
            source(e2, g), target(e2, g),
        };
 
        return graphconnexe(g) && vertex_set.size() < 4;
    }
//===============if the graph is empty add the edge with vertices===========================
void emptygraphaddedge(Graph& testg,std::vector<Graph> dataG) {
 
      if (!dataG.empty()) {
        auto const& gr = dataG.front(); // firslt graph in G_list
        auto ep = edges(gr).first; // first edge in gr
 
        vertex_t from = source(*ep, gr);
        vertex_t to = target(*ep, gr);
 
        //int cpt=0;
        boost::add_vertex(VertexProperties(gr[from].id, gr[from].label),testg);
        //boost::add_vertex(VertexProperties(cpt, gr[from].label),testg);
 
        boost::add_vertex(VertexProperties(gr[to].id, gr[to].label),testg);
        //boost::add_vertex(VertexProperties(cpt+1, gr[to].label),testg);
 
 
 
        if(verticeexist(testg,gr[from].id,gr[from].label)&&verticeexist(testg,gr[to].id,gr[to].label))
        {
            int cpt=0;
            Graph::edge_descriptor copied_edge = boost::add_edge(cpt, cpt++, gr[*ep],testg).first;
            testg[source(copied_edge, gr)] = gr[from];
            testg[target(copied_edge,gr)] = gr[to];
            cout<<"e ("<<testg[source(copied_edge, gr)].id<<","<<testg[target(copied_edge, gr)].id<<") Added successfully."<<endl;
        }
        else{cout<<"vertices doesn't exist ! "<<endl;}
 
    }
 
}
//======================================================
float frequency(Graph const& g1,std::vector<Graph> dataG)
{
    int iso=0;
 
    if(emptygraph(g1)){return 1;}
    else{
    for (Graph g2: dataG)
    {
        if(vf2_subgraph_iso(g1,g2,my_callback())){iso++;}
    }
 
    return (iso/dataG.size());
    }
 
}
//==========test if the edge is connexe with the graph=============
bool graphconnexewithedge(Graph g, int const& fromid, int const& toid) {
    return (idverticeexist(g,fromid)|| idverticeexist(g,toid));
}
//=========test if the aumentation is is a subgraph of the original graph=================================
void augmentation(Graph &M, Graph &g, int const& fromid, int const& toid, unsigned const& elabel, unsigned const& edgeid) {
 
 
	if(!idverticeexist(g,fromid)){ int vlabel=getvlabel(M,fromid);
	           boost::add_vertex(VertexProperties(fromid, vlabel), g);
	                              }
 
	if(!idverticeexist(g,toid)){ int vlabel=getvlabel(M,toid);
		boost::add_vertex(VertexProperties(toid, vlabel), g);
	}
 
	boost::add_edge(fromid, toid, EdgeProperties(edgeid, elabel), g);
 
}
//===========================================================
/*bool myfunction (edge_iter i,edge_iter j) { return (i<j); }
 
struct myclass {
  bool operator() (edge_iter i,edge_iter j) { return (i<j);}
} myobject;
*/
template <typename Graph, typename E = typename boost::graph_traits<Graph>::edge_descriptor>
std::vector<E> edgesdiff(Graph const& g1,Graph const& g2){
 
std::vector<E> v1;
std::vector<E> v2;
std::vector<E> result;
 
edge_iter ei, ei_end;
tie(ei, ei_end) = edges(g1);
std::for_each(ei, ei_end, [&](const edge_iter& it) {v1.push_back(*it); });
/*
typedef graph_traits<Graph>::edge_iterator edge_iter;
std::pair<edge_iter, edge_iter> ep;
 
edge_iter ei, ei_end;
for (tie(ei, ei_end) = edges(g1); ei != ei_end; ++ei){v1.push_back(ei);}
for (tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei){v2.push_back(ei);}
 
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
 
 
    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(result));
 
*/
return result;
}
//==============================M A I N   P R O G R A M =======================================
int main() {
//clock_t start = std::clock();
size_t length;
std::vector<Graph> dataG =creategraphs(splitstringtolines(readfromfile("60.txt", length)));
 
 
cout<<"edgesdiff().size()="<<edgesdiff(dataG[10],dataG[39]).size()<<endl;
 
 
/*
cout << "FILE Contains " << dataG.size() << " graphs.\nTIME: " << (std::clock() - start) / (double)CLOCKS_PER_SEC<< "s" << endl; // fin du programme.
*/
 
}

26/03/2015, 11h30
ternel

Je parlais de "après le message d'erreur".
avec gcc ou mingw, normalement tu as des lignes "notice: candidate is ..."

Citation:

Envoyé par leternel

Je parlais de "après le message d'erreur".
avec gcc ou mingw, normalement tu as des lignes "notice: candidate is ..."

J'utilise CodeBlocks et voila toutes les erreurs:

Code:

1
2
3
4
5
6
7
8
9
10
11
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp||In function ‘void emptygraphaddedge(Graph&, std::vector<boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties> >)’:|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|308|warning: operation on ‘cpt’ may be undefined [-Wsequence-point]|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|308|warning: operation on ‘cpt’ may be undefined [-Wsequence-point]|
/usr/include/c++/4.9/bits/stl_algo.h||In instantiation of ‘_Funct std::for_each(_IIter, _IIter, _Funct) [with _IIter = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>; _Funct = edgesdiff(const Graph&, const Graph&) [with Graph = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties>; E = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>]::<lambda(const edge_iter&)>]’:|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|369|required from ‘std::vector<E> edgesdiff(const Graph&, const Graph&) [with Graph = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties>; E = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>]’|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|398|required from here|
/usr/include/c++/4.9/bits/stl_algo.h|3755|error: no match for call to ‘(edgesdiff(const Graph&, const Graph&) [with Graph = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties>; E = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>]::<lambda(const edge_iter&)>) (boost::iterator_facade<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, boost::bidirectional_traversal_tag, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>::reference)’|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|369|note: candidate is:|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|369|note: edgesdiff(const Graph&, const Graph&)::<lambda(const edge_iter&)> [with Graph = boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, VertexProperties, EdgeProperties, GraphProperties>; E = boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>; edge_iter = boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>]|
/home/mohsenuss91/Bureau/NouvelleApprocheBOOST/methodlire_v18.cpp|369|note:   no known conversion for argument 1 from ‘boost::iterator_facade<boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, boost::bidirectional_traversal_tag, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>::reference {aka boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>}’ to ‘const edge_iter& {aka const boost::detail::undirected_edge_iter<std::_List_iterator<boost::list_edge<unsigned int, EdgeProperties> >, boost::detail::edge_desc_impl<boost::undirected_tag, unsigned int>, int>&}’|
||=== Build failed: 1 error(s), 5 warning(s) (0 minute(s), 6 second(s)) ===|

26/03/2015, 12h37
stendhal666

Le code source est différent de la fonction que tu nous as montrée dans les précédents messages...
26/03/2015, 13h21
mohsenuss91

Citation:

Envoyé par stendhal666

Le code source est différent de la fonction que tu nous as montrée dans les précédents messages...

J'ai modifié le post, c'est la dernière mise a jour du programme.
26/03/2015, 13h30
stendhal666

Dans ce cas, tu crées toujours des vecteurs d'itérateurs, pas d'arêtes, et les mêmes problèmes se posent pour leur tri...

J'ai modifié la fonction:

std::vector<int*> edgesdiff(Graph const& g1,Graph const& g2)
retourne la différence entre les arêtes de deux graphe dans un vector,
ici il y a un petit problème que je ne comprends pas, les valeurs insérées sont juste mais lorsque je fais l'affichage pour vérifier j’obtiens les adresses au lieu des valeurs!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 std::vector<int*> edgesdiff(Graph const& g1,Graph const& g2){ std::vector<edge_iter> v1; std::vector<edge_iter> v2; //std::vector<int [3]> result; std::vector<int*> result = std::vector<int*>(); edge_iter ei, ei_end; for (tie(ei, ei_end) = edges(g1); ei != ei_end; ++ei){v1.push_back(ei);} for (tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei){v2.push_back(ei);} cout<<"***Insertion diff***"<<endl; for(auto x:v1){if(!edgeexistinavector(g1,x,g2,v2)){ int t[3]; vertex_t from = source(*x, g1); t[0]=g1[from].id; cout<<"g1[from].id="<<g1[from].id<<endl; vertex_t to = target(*x, g1); t[1]=g1[to].id; cout<<"g1[to].id="<<g1[to].id<<endl; edge_t edg = edge(from, to, g1); t[2]=g1[edg.first].label; cout<<"g1[edg.first].label="<<g1[edg.first].label<<endl; result.push_back(t); } }
Voila le code source complet: http://pastebin.com/wxTeABhU

31/03/2015, 10h36
stendhal666
Comme result est un vecteur de pointeurs sur int (std::vector<int*>), il est bien normal que tu tombes sur des adresses et pas sur des valeurs...
Si tu veux obtenir les valeurs dans les tableaux sur lesquels les éléments de result pointent, il faut que tu ailles les chercher, par ex:
Code:

1 2 3 4 5 6 7 void afficheValeurs(int* pi) { std::cout << '[' for (unsigned u = 0; u < 3; ++u) { std::cout << pi[u] << " "; } std::cout << ']'; }
01/04/2015, 12h32
mohsenuss91
Code:

1 2 3 4 5 6 std::cout << '[' for (unsigned u = 0; u < 3; ++u) { std::cout << pi[u] << " "; } std::cout << ']';
ça donne toujours des adresse :( mais le problème à été résolu en utilisant

Code:

std::vector<std::<array<int, 3>>

Merci a vous.