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