Discussion :

[bowow]

Bonsoir,

je suis en train d'implémenter une solution d'écriture d'un arbre de données binaires (structures) dans un fichier via les flux ofstream.
jusqu'à présent, je créais trois vecteur<A/B/C> selon le type de données et tout se passe bien.

Maintenant, admettons j'ai 3 structures différentes:

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
 
struct A
{
   int value;
   char c;
}
 
struct B
{
   int value;
   char c;
}
 
struct C
{
   int value;
   char c;
}
 
int main ()
{
    A sa;
    B sb;
    C sc;
    std::vector<multi_types> v;
    v.emplace_back(sa);
    v.emplace_back(sb);
    v.emplace_back(sc);
}

Désormais, je souhaiterais stocker toutes les données des 3 structures dans un même vector, une solution générique combinant les classes, les templates ou les smarts pointeurs éventuellement, est ce possible?

Merci.

[LandReagan]

Bonjour,

En utilisant l'héritage pour faire une interface? Si tu fais dériver tes 3 structures d'une classe abstraite commune, tu peux ensuite créer un conteneur de smart pointer de cette classe abstraite et ainsi stocker tes structures dans un conteneur commun.

[jo_link_noir]

Comme boost::any ou boost::variant quand les types sont connus.

[bowow]

Ok LandReagan, si j'ai bien compris, tu proposes une solution comme celle-ci, à peu près ?

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
 
#ifndef VECTOR_H
#define VECTOR_H
 
template <typename T>
class multi_types
{
	public:
	virtual ~multi_types() {}
	virtual T get_value() const = 0;
 
};
 
template <typename T>
class type : public multi_types
{
	private:
	T		m_value;
 
	public:
	type(const T& value) : m_value(value) {}
	virtual T get_value() const { return m_value;  }
 
};
#endif
 
int main ()
{
    std::vector<std::unique_ptr<multi_types>> v;
}

Je vais regarder ta solution aussi jo_link_noir, je n'ai pas encore installé boost là.

[jo_link_noir]

Un multi_type ressemble plus à:

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
#include <memory>
#include <utility>
#include <type_traits>
#include <typeinfo>
 
 
class multi_type {
  struct base {};
 
  template<class T>
  struct internal : base 
  {
     T x;
     template<class... Args>
     internal(Args&&... args)
     : x(std::forward<Args>(args)...)
     {}
  };
 
public:
  template<class T>
  multi_type(T && x)
  : p_(new internal<typename std::decay<T>::type>(std::forward<T>(x)))
  , type_(&typeid(T))
  {}
 
  std::type_info const & type() const { return *type_; };
 
  template<class T>
  friend T * multi_type_cast(multi_type & m)
  {
    if (m.type().hash_code() == typeid(T).hash_code()) {
      return &static_cast<internal<T>*>(m.p_.get())->x;
    }
    return nullptr;
  }
 
private:
  std::unique_ptr<base> p_;
  std::type_info const * type_;
};

Mais franchement, une union serait plus bénéfique.

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
struct variant{
  union U { A a; B b; C c; /*char dummy[max_sizeof<A,B,C>()]; U():dummy(){}*/ } u;
  static constexpr unsigned noindex = -1u;
  unsigned idx = noindex;
 
  template<class T>
  variant(T && x)
  {
     new (u.a) std::decay_t<T>(std::forward<T>(x));
     idx = get_idx<T>();
  }
 
  ~variant()
  {
     if (idx != noindex) {
       visit([](auto & x) { 
         using T = decltype(x);
         x.~T();
       });
     }
  }
 
  template<class Fn>
  void visit(Fn fn) {
    switch(idx) {
      case 0: fn(u.a); break;
      case 1: fn(u.b); break;
      case 2: fn(u.c); break;
      default: ;
    }
  }
};

(pas testé, juste pour l'idée)

Mais cela demande du travail pour être bien. Encore plus si on veut des classes génériques. Au moins dans boost le travail est déjà fait.

[bowow]

Ok, quand tu dis que le travaille est déjà fait avec la librairie boost, tu fais allusion à ça ? http://www.boost.org/doc/libs/1_58_0...l/variant.html

[jo_link_noir]

Oui

[bowow]

Ok, je n'ai pas encore tout saisi je pense, mais en fait j'ai juste à écrire ça et c'est bon ?

Code :

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

1
2
3
4
 
std::vector<boost::variant<A, B, C>> v;
A sa;
v.emplace_back(sa);

[jo_link_noir]

Tous simplement

Après il faut utiliser boost::apply_visitor pour manipuler les valeurs, comme dans l'exemple.
Rien de plus.

[bowow]

ouais justement, parlons en de la récupération des valeurs, par exemple, lors de l'écriture du vecteur des structures

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <typename T>
bool write(const std::string& path, std::vector<T>& vish)
{
	std::ofstream of(path, std::ios::out | std::ios::binary);
	if (!of) return false;
 
	for (auto& it : vish)
		of.write(reinterpret_cast<char*>(&it), sizeof(T));
 
	return true;
}

Comment est interprété le sizeof(T) ? Il prend la taille de l'ensemble des 3 structures A, B, C ?
Comment réagit boost::variant ? est-il capable de "détecter" automatiquement quelle structure est concernée et ne retourner la taille que d'une seule structure ?

de plus, boost::static_visitor<> ne prend pas de struct.

[jo_link_noir]

boost::static_visitor sert de classe de base pour indiquer le type de retour du visiteur, je ne comprends pas le "ne prend de classe" ?

Dommage que apply_visitor ne fonctionne pas avec des lambdas

[LandReagan]

Ohlala pardon, je me suis engagé dans une discussion pour laquelle j'ai bien peur de ne pas avoir le niveau! Je crois que je n'ai pas compris le problème. Mais je vais en profiter pour poser des questions:
-Pourquoi le recours à la programmation générique?

Voilà ce que j'entrevoyais:

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
 
class AbstractData
{
public:
   //Les méthodes virtuelles pures, comme:
   bool write(const std::string& path) const = 0; // peut-être vaut-il mieux envoyer directement une ref sur le ofstream, du coup...
}
 
class A : public AbstractData
{
public:
   int value;
   char c;
 
   bool write(const std::string& path) const
   {
      // le code qui va bien pour sortir les données
   }
}
 
// ... même chose pour B et C ...
 
int main()
{
   std::unique_ptr<AbstractData> pa (new A())
   std::unique_ptr<AbstractData> pb (new B())
   std::unique_ptr<AbstractData> pc (new C())
 
   std::vector<unique_ptr<AbstractData> > v;
   v.push_back(pa);
   v.push_back(pb);
   v.push_back(pc);
 
   return 0;
}

C'est ce que j'avais compris du problème, mais c'est sûrement trop simple.

[Flob90]

Dommage que apply_visitor ne fonctionne pas avec des lambdas

apply_visitor fonctionne avec des lambdas (en C++14), et plus généralement avec tout ce qui respecte le concept de visiteur statique (le concept inclut la détection automatique du type de retour en C++14).

@OP: Est-ce que tu connais exactement la liste des types que tu veux gérer ou est-ce qu'elle est amenée à évoluer ? Plus exactement est-ce que lors de la déclaration de ton conteneur tu connais exactement les types possibles ou non ? D'autre part, est-ce que les algorithmes que tu vas appliquer dépendent uniquement du type d'un objet de ton conteneur, ou tu peux être amener à appliquer un algorithme dépendant des types de plusieurs objets ?

Selon ces réponses je vois deux solutions : Boost.Variant ou Boost.TypeErasure.

[jo_link_noir]

C'est une solution tout à fait possible. Ce qu'il faut savoir ensuite, c'est si la méthode d'écriture fait partie de l'interface. Est-ce le rôle de la classe ? Dans quel format ?
Il faut aussi se demander comment va être manipulé la classe dans le cas général. Je pense qu'ici connaître le type est un prérequis et l'écriture est un cas particulier. C'est pour ça que mettre la fonction d'écriture à l’extérieur me semble la meilleure solution. Et là, il y a 2 solutions:
- polymorphisme (via une classe qui ne sait faire que l'écriture et dont les filles prennent le type réel) ou
- pattern visiteur (plus léger que le polymorphisme et utilisé quand les types utilisés sont restreint et connu à l'avance).

@Flob90: Je dois avoir quelques versions de retard, il cherche systématiquement result_type dans la lambda.

[Flob90]

C'est une solution tout à fait possible. Ce qu'il faut savoir ensuite, c'est si la méthode d'écriture fait partie de l'interface. Est-ce le rôle de la classe ? Dans quel format ?
Il faut aussi se demander comment va être manipulé la classe dans le cas général. Je pense qu'ici connaître le type est un prérequis et l'écriture est un cas particulier. C'est pour ça que mettre la fonction d'écriture à l’extérieur me semble la meilleure solution. Et là, il y a 2 solutions:
- polymorphisme (via une classe qui ne sait faire que l'écriture et dont les filles prennent le type réel) ou
- pattern visiteur (plus léger que le polymorphisme et utilisé quand les types utilisés sont restreint et connu à l'avance).

@Flob90: Je dois avoir quelques versions de retard, il cherche systématiquement result_type dans la lambda.

Oui, c'est dans la dernière version (1.58) d'après la doc. Si tu ne peux pas mettre à jour, c'est pas très compliquer d'écrire un helper qui va te transformer ta lambda en un visiteur statique.

[bowow]

apply_visitor fonctionne avec des lambdas (en C++14)

Je suis sous visual studio C++ express 2013, donc dans l'état actuel des choses, il ne risque pas de prendre en compte les évolutions du C++2014.

Est-ce que tu connais exactement la liste des types que tu veux gérer ou est-ce qu'elle est amenée à évoluer ? Plus exactement est-ce que lors de la déclaration de ton conteneur tu connais exactement les types possibles ou non ? D'autre part, est-ce que les algorithmes que tu vas appliquer dépendent uniquement du type d'un objet de ton conteneur, ou tu peux être amener à appliquer un algorithme dépendant des types de plusieurs objets ?

J'ai trois structures distinctes, avec des uint32_t pour stocker les valeurs et uint64_t pour stocker les offsets, donc oui, je connais exactement les types de données et elles ne sont pas susceptible d'évoluer.
Je cherche à faire une solution générique, utilisable dans n'importe quel projet et qui puisse créer un conteneur multiple gérant aussi bien des class, structs, ou des int et std::string comme dans l'exemple sur le site de boost::variant.
Sachant que chaque structure a un rôle bien défini, chacune stocke différentes valeurs, donc les algorithmes diffèrent selon sur laquelle je travaille.

[Flob90]

La remarque pour le C++14 était uniquement pour l'utilisation des lambda, tu n'en as pas besoin dans l'absolu.

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
 
struct ostream_visitor
	: boost::static_visitor<void>
{
	ostream_visitor(std::ostream& os)
		: os(os)
	{}
	template<class Data>
	void operator()(const Data& data) const
	{ os << data; }
 
private:
	std::ostream& os;
};
 
 
template <class Range>
std::ostream& operator<<(std::ostream& os, const Range& range)
{
	ostream_visitor visitor(os);
	for (const auto& data : range)
		boost::apply_visitor(visitor, data);
 
	return os;
}

Après tu mets un peu ce que tu veux dans le ostream_visitor, là j'ai fait un traitement commun à tout les types, mais tu peux surcharger pour chaque type possible.

Par contre quand tu veux appliquer une opération à un variant, tu dois passer par un visiteur, si tu fais directement une opération, tu n'auras probablement pas le résultat attendu.

Edit: Code non testé