Discussion :

[3DArchi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[r0d]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
	}
}

[yan]

Salut

tu pourrais aussi faire un truc comme cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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...