Recursion de std::accumulate.

Version imprimable

Bonjour,
J'ai un ensemble de classes où chacune contient une liste de la classe suivante. J'aimerais à partir du sommet obtenir le total des éléments. Un peu de code pour mieux comprendre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
class A
{
public:
   std::vector<int> m_vectElts;
};
 
class B
{
public:
   std::vector<A> m_vectA;
};
 
class C
{
public:
   std::vector<B> m_vectB;
};

Partant d'un objet C, j'aimerais savoir combien de int j'ai au total.
Aujourd'hui j'arrive à faire ça:

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
 
class A
{
public:
   std::vector<int> m_vectElts;
 
   int NbrElts()
   {
      return m_vectElts.size();
   }
};
 
class B
{
public:
   std::vector<A> m_vectA;
 
   int NbrElts()
   {
       return std::accumulate
       (
           boost::make_transform_iterator(m_vectA.begin(),std::mem_fun_ref(&A::NbrElts)),
           boost::make_transform_iterator(m_vectA.end(),std::mem_fun_ref(&A::NbrElts)),
           0
       );
   }
};
 
class C
{
public:
   std::vector<B> m_vectB;
 
   int NbrElts()
   {
       return std::accumulate
       (
           boost::make_transform_iterator(m_vectB.begin(),std::mem_fun_ref(&B::NbrElts)),
           boost::make_transform_iterator(m_vectB.end(),std::mem_fun_ref(&B::NbrElts)),
           0
       );
   }
 
};
 
Puis les éléments:
std::cout<<c.NbrElts();

Mais, trimbaler un NbrElts tout le long de la chaîne ne me plaît pas trop. Je n'arrive pas à faire cette récursion avec boost. Je n'arrive pas à sortir quelque chose du genre:

Code:

1
2
3
4
5
6
7
8
9
 
std::accumulate
(
  boost::make_transform_iterator(
   MonC.m_vectB.begin(),std::accumulate(???)),
  boost::make_transform_iterator(
   MonC.m_vectB.end(),std::accumulate(???)),
  0
);

Quelqu'un aurait-il une idée?

accumulate effectue l'addition de chaque élément. Si j'ai bien compris, toi tu souhaites juste compter le nombre d'éléments. Dans ce cas, une simple boucle suffit. Un truc dans le style:
Code:

1 2 3 4 5 6 7 8 9 C c; std::vector<B>::const_iterator it1 = c.m_vectB.begin(); size_t sum = 0; for ( ; it1 != c.m_vectB.end(); ++it1 ) { std::vector<B>::const_iterator it2 = (*it).m_vectA.begin(); for ( ; it2 != (*it).m_vectA.end(); ++it2 ) { sum += (*it2).m_vectElts.size(); } }

Salut

tu pourrais aussi faire un truc comme cela

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
struct A
{
   std::vector<int> m_vectElts;
};
 
struct B
{
   std::vector<A> m_vectA;
};
 
struct C
{
   std::vector<B> m_vectB; 
};
 
template <typename T>
struct count
{
    int operator() (int i,const  T &t)
    {
        return 0;
    }
};
template <>
int count<A>::operator() (int i,const  A &a)
{
    return i+a.m_vectElts.size();
}
template <>
int count<B>::operator() (int i,const  B &b)
{
    return i+std::accumulate(b.m_vectA.begin(),b.m_vectA.end(),0,count<A>());
}
 
 
int main(int argc, char* argv[])
{
    A a;
    B b;
    C c;
    a.m_vectElts.resize(10);
    b.m_vectA.push_back(a);
    b.m_vectA.push_back(a);
    b.m_vectA.push_back(a);
 
    c.m_vectB.push_back(b);
    c.m_vectB.push_back(b);
    c.m_vectB.push_back(b);
 
    std::cout<<std::accumulate(c.m_vectB.begin(),c.m_vectB.end(),0,count<B>());
	return 0;
}

02/09/2008, 08h47
3DArchi

Merci pour les réponses.
La nuit portant conseil, j'ai bien pensé me servir de classes template tierces pour m'assurer du comptage. Donc quelque chose comme ce que suggère MonGaulois. Au boulot donc pour mettre en application...