Discussion :

[Nogane]

Bonjour,
Je suis confronté a un problème que je pensai simple, et qui finalement ne semble pas l'être.
- Parcourir un boost::tuple de type et de taille inconnue.
En effet il n'y a pas d'iterateur, ni de BOOST_FOREACH, pour les tuple.
De plus il y a bien un accesseur par index, mais l'index doit être connue a la compilation.

Ma première idée été donc de faire quelque chose comme ceci:

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
#include <iostream>
#include <boost/tuple/tuple.hpp>
#include <boost/static_assert.hpp>
 
using namespace std;
using namespace boost;
 
template<class T>
void coutTuple(const T &myTuple)
{
  static const int len = tuples::length<T>::value; //len est connu a la compilation
  BOOST_STATIC_ASSERT(len == 1);
  if(len > 0)
  {
    cout << myTuple.get<0>();
    if(len > 1) //donc cette contition est fausse, puisque len == 1
    {
      cout << myTuple.get<1>(); //Pourtant il y a quand meme une erreur ici
      if(len > 2)
      {
        cout << myTuple.get<2>(); //et ici
        //if(len > 3) etc...
      }
    }
  }
}
 
int main()
{
  tuple<int> myTuple(21548);
  coutTuple(myTuple);
  return 0;
}

Ce n'est pas très joli, et la taille du tuple est limité, mais je pensai qu'au moins ça marcherais.
Et bien non car le compilateur semble vouloir compiler les lignes dont il sait pertinemment qu'elle ne seront jamais exécutées. Ce qui me surprend un peu.

En poussant un peu le bouchon j'ai testé ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int main()
{
  if(false)  
  {
    tuple<int> myTuple(21548);
    coutTuple(myTuple);
  }
  return 0;
}

Le problème reste exactement le même. Ce qui veux dire que mon compilo tente d'instancier coutTuple<tuple<int> > alors qu'il sait bien que cette fonction ne sera jamais appelé.
(Je suis sur minGW 5.1.4, et le problème semble indépendant des option de compilation)

Quelqu'un aurait t'il une solution?
Ou au moins une explication?

[Matthieu Brucher]

Attention, tu confonds pas mal de choses. A la base, le compilateur instancie ce qui est nécessaire. A ce moment, il ne sait pas encore si les conditions s'évaluent toujours à true ou false.
Ce n'est que lors de la phase d'optimisation que certaines branches vont être supprimées.

Si tu veux éviter l'instanciation, ta seule option est la spécialisation de template.

[Nogane]

Si tu veux éviter l'instanciation, ta seule option est la spécialisation de template.

Merci beaucoup pour cette précision.
Je suis justement entrain de tester une solution a base de spécialisation template.

[Nogane]

Bon j'ai eu du mal a trouver alors je vous donne la solution.
(Je la posterai dans le forum "contribuez" si ça intéresse quelqu'un)

Voila le header:

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
#ifndef FOREACHTUPLE_H_INCLUDED
#define FOREACHTUPLE_H_INCLUDED
 
#include <boost/tuple/tuple.hpp>
 
template<int index, class T, class F>
struct ForeachTuple
{
  void operator()(const T &myTuple, const F &func)
  {
    using namespace boost;
    static const int tupleLen = boost::tuples::length<T>::value;
    func(myTuple.get<(tupleLen - 1) - index>());
    ForeachTuple<index- 1, T, F>()(myTuple, func);
  }
};
 
template<class T, class F>
struct ForeachTuple<0, T, F>
{
  void operator()(const T &myTuple, const F &func)
  {
    using namespace boost;
    static const int tupleLen = boost::tuples::length<T>::value;
    func(myTuple.get<tupleLen - 1>());
  }
};
 
template<class T, class F>
void foreachTuple(const T &myTuple, const F &func)
{
  ForeachTuple<boost::tuples::length<T>::value - 1, T, F>()(myTuple, func);
}
 
#endif // FOREACHTUPLE_H_INCLUDED

Et voila comment l'utiliser:

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
#include <iostream>
#include <boost/tuple/tuple.hpp>
#include "foreachTuple.h"
 
struct DisplayValue
{
  template<class T>
  void operator()(const T &val) const
  {
    std::cout << val << std::endl;
  }
};
 
int main()
{
  boost::tuple<int, int , int, double, char> myTuple(1, 2, 3, 4.5941, 'e');
  foreachTuple(myTuple, DisplayValue());
  return 0;
}

Ça fonctionne un peu comme le std::foreach, mais sur les tuple.

[loufoque]

Les opérations pour les tuples, c'est dans Boost.Fusion.
http://www.boost.org/doc/libs/1_38_0.../for_each.html pour un for_each à l'exécution (peut aussi se faire à la compilation)

[Nogane]

Oui en effet. Je m'en suis rendu compte depuis. Pas facile a trouver, quand même.

[loufoque]

Comment ça pas facile ? T'arrives dans la doc de Boost.Fusion, tu vois direct dans le sommaire Algorithm > Iteration > Functions, tu cliques, puis tu cliques sur for_each, et t'y es.

[Nogane]

Oui mais faut-il encore savoir que ça se trouve dans boost.fusion
Moi je cherchai bêtement dans boost.tuple
Je n'ai hélas pas encore pris le temps de parcourir l'ensemble des bibliothèque de boost. Je ferais mieux de me dépêcher parce qu'il y en as de plus en plus!!