Transport de template

Version imprimable

Bonjour à tous.

Voilà, j'ai un petit soucis avec mes templates qui me pose de sacrée problèmes. Je voudrais pouvoir transporter de façon "générique" une liste de template differents.

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // Une classe template template<typename T> class Test { public: T variable ; ... }; // Et plus loin Test list[2] ; list[0] = Test<int>() ; list[1] = Test<double>() ; for (i=0; i<1; i++) { cout << list[i].variable << endl ; }
Voilà, je voudrais un truc plus où moins dans le genre. Mais comme vous vous en doutez, le "Test list[2]" est impossible car il faut un type de template.
Donc j'aurai voulu savoir comment rendre ce tableau generique. (Même si c'est un peu tordu, parce pour le moment, je vois pas comment m'en sortir)

Merci à tous ! ;)

Il te faut utiliser un typage dynamique.
Le typage dynamique le plus utilisé en C++ est probablement le typage dynamique objet.

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
class Test_base
{
public:
    virtual std::ostream& display(std::ostream&) const = 0;
    virtual ~Test_base() {}
};
 
std::ostream& operator<<(std::ostream& os, const Test_base& t)
{
    return t.display(os);
}
 
template<typename T>
class Test : public Test_base
{
public:
    T variable;
 
    std::ostream& display(std::ostream& os) const
    {
        return os << variable;
    }
};
 
Test_base* list[2] ;
list[0] = new Test<int>() ;
list[1] = new Test<double>() ;
 
for (i=0; i<2; i++)
{
    cout << *list[i] << endl ;
}
 
for(i=0; i<2; i++)
    delete list[i];

31/08/2007, 16h57
yan

Citation:

Envoyé par loufoque

Il te faut utiliser un typage dynamique.
Le typage dynamique le plus utilisé en C++ est probablement le typage dynamique objet.

Qu'es qui existe à part le typage dynamique objet?
31/08/2007, 17h32
loufoque

Le variant et le duck typing.
31/08/2007, 17h52
Jean-Marc.Bourguet

Citation:

Envoyé par loufoque

Le variant et le duck typing.

Comment tu fais tu duck typing dynamique en C++?

Ce n'est pas vraiment possible, il faudrait avoir des template virtuals ou similaire pour ça.
On peut néanmoins se débrouiller si on se limite à une liste pré-déterminée de types, et qu'on dispose d'introspection.

Voici un petit truc que j'avais fait par exemple

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <iostream>
#include <string>
#include <stdexcept>
 
#include <boost/mpl/map.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/vector_c.hpp>
 
#include <boost/mpl/at.hpp>
#include <boost/mpl/has_key.hpp>
#include <boost/mpl/front.hpp>
 
#include <boost/mpl/and.hpp>
#include <boost/mpl/equal.hpp>
#include <boost/mpl/find_if.hpp>
 
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/variant.hpp>
 
template<typename T>
struct reflection
{
};
 
template<typename T, typename Name, typename Args>
struct has_member
{
	typedef typename boost::mpl::eval_if<
		boost::mpl::has_key<
			typename reflection<T>::type,
			Name
		>,
		boost::mpl::find_if<
			typename boost::mpl::at<
				typename reflection<T>::type,
				Name
			>::type,
 
			boost::mpl::bind<	
				boost::mpl::quote3<boost::mpl::equal>,
 
				boost::mpl::bind<
					boost::mpl::quote1<boost::mpl::second>,
					boost::mpl::_1
				>,
				Args,
 
				boost::is_convertible<
					boost::mpl::_1,
					boost::mpl::_2
				>
			>
		>,
		boost::mpl::void_
	>::type iter;
 
	static const bool value = 
		boost::mpl::eval_if<
			boost::mpl::not_<
				boost::is_same<
					iter,
					boost::mpl::void_
				>
			>,
			boost::mpl::not_<
				boost::is_same<
					iter,
					typename boost::mpl::end<
						typename boost::mpl::at<
							typename reflection<T>::type,
							Name
						>::type
					>::type
				>
			>,
			boost::mpl::false_
		>::type::value;
 
	typedef bool value_type;
	typedef has_member<T, Name, Args> type;
 
	typedef typename boost::mpl::eval_if<
		boost::mpl::bool_<value>,
		boost::mpl::first<
			typename boost::mpl::deref<iter>::type
		>,
		boost::mpl::void_
	>::type return_type;
};
 
template<>
struct reflection<std::string>
{
	typedef boost::mpl::map<
		boost::mpl::pair<
			boost::mpl::vector_c<char, 'c', '_', 's', 't', 'r'>,
			boost::mpl::vector<
				boost::mpl::pair<
					const char*,
					boost::mpl::vector<>
				>
			>
		>
	> type;
};
 
template<>
struct reflection<int>
{
	typedef boost::mpl::map<
	> type;
};
 
typedef boost::variant<int, std::string> variant;
 
class visitor : public boost::static_visitor<variant>
{
public:
	template<typename T>
	typename boost::enable_if<
		has_member<T, boost::mpl::vector_c<char, 'c', '_', 's', 't', 'r'>, boost::mpl::vector<> >,
		variant
	>::type
	operator()(T& t) const
    {
        std::cout << t.c_str() << std::endl;
    }
 
	template<typename T>
	typename boost::disable_if<
		has_member<T, boost::mpl::vector_c<char, 'c', '_', 's', 't', 'r'>, boost::mpl::vector<> >,
		variant
	>::type
	operator()(T& t) const
	{
		throw std::runtime_error("type " + std::string(typeid(T).name()) + " doesn't have c_str()");
	}
};
 
int main()
{
    variant u1 = std::string("hello");
    variant u2 = 4;
 
    boost::apply_visitor( visitor(), u1 ); // same as u1.c_str()
    boost::apply_visitor( visitor(), u2 ); // same as u2.c_str()
}

Le format d'introspection est pas terrible, il faudrait qu'on puisse appeler les fonctions membres à partir de leur nom (ce qui permettrait d'automatiser la création des foncteurs)

Merci beaucoup pour vos réponses, ça m'a bien débloqué.

Mais je reste coincé sur un soucis plus sérieux à cause des templates.
J'ai fait ç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 template<class T> class Variable ; /**** * Classe de base ****/ class VariableBase { public: virtual ~VariableBase() {} virtual kougar::ustring toString() = 0 ; template<typename V> virtual bool operator== (Variable<V>& br) const = 0 ; } ; /**** * Classe Variable ****/ template<class T> class Variable : public VariableBase { protected: T* var ; public: Variable() : var(NULL) {} Variable(T& variable) : var(&variable) {} kougar::ustring toString() { std::ostringstream f ; f << *var ; return f.str() ; } template<typename V> bool operator== (Variable<V>& br) const { return *var == *(br.var) ; } } ;
Et le code d'utilisation d'exemple pour montrer l'interet :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int a = 5 ; int b = 10 ; std::string c = "test" ; VariableBase* va = new Variable<int>(a) ; VariableBase* vb = new Variable<int>(b) ; VariableBase* vc = new Variable<std::string>(c) ; if (*va==*vb) { cout << "Ok" << endl ; } if (*va==*vc) { cout << "Ok" << endl ; }
Le soucis, comme vous pouvez le voir c'est sur le

Code:

template<typename V> virtual bool operator== (Variable<V>& br) const = 0 ;

qui est complètement interdit par le C++.

Je voudrais donc savoir comment pouvoir faire une comparaison entre 2 classes Variable alors que je n'ai que le pointeur générique sur la classe VariableBase.

Encore merci pour vos réponse.

03/09/2007, 12h25
PierroElMito

Tu veux stocker quels types dans ta liste? Si tu ne veux mettre que des types de base, tu peux utiliser boost::variant.
http://www.boost.org/doc/html/variant.html

Citation:

The variant class template is a safe, generic, stack-based discriminated union container, offering a simple solution for manipulating an object from a heterogeneous set of types in a uniform manner. Whereas standard containers such as std::vector may be thought of as "multi-value, single type," variant is "multi-type, single value."
03/09/2007, 12h51
screetch

sympa ta localisation PierroElMito. Ca prouve que ca depend pas de l'age.
03/09/2007, 13h13
Snark
Citation:

Envoyé par PierroElMito

Tu veux stocker quels types dans ta liste? Si tu ne veux mettre que des types de base, tu peux utiliser boost::variant.
http://www.boost.org/doc/html/variant.html

Merci. J'avais déjà vu cette classe mais elle me convient pas pour plusieurs raison :
- Elle oblige une grosse dépendance pour pas grand chose
- J'ai besoin de garder un certain contrôl sur la classe conteneur.
- Comme tu le dis, elle ne gère que les types de bases.

J'ai tenté de faire de la classe découlante une classe "friend" comme ça :
Code:

1 2 3 4 5 6 class VariableBase { [...] template<class T> template<class V> friend bool Variable<T>::operator== (Variable<V>& br) const ; [...] };
Mais il n'a pas l'air d'aprécié, il me sort une erreur :

Citation:

erreur: member «bool ktpl::Variable<T>::operator==(ktpl::Variable<V>&) const" declared as friend before type «ktpl::Variable<T>" defined

Une idée ? :)
03/09/2007, 13h46
HanLee
Citation:
Envoyé par Snark

Merci. J'avais déjà vu cette classe mais elle me convient pas pour plusieurs raison :
- Elle oblige une grosse dépendance pour pas grand chose
- J'ai besoin de garder un certain contrôl sur la classe conteneur.
- Comme tu le dis, elle ne gère que les types de bases.

J'ai tenté de faire de la classe découlante une classe "friend" comme ça :

Code:

1 2 3 4 5 6 class VariableBase { [...] template<class T> template<class V> friend bool Variable<T>::operator== (Variable<V>& br) const ; [...] };

Mais il n'a pas l'air d'aprécié, il me sort une erreur :

Une idée ? :)
Non boost::variant gère tous les types à sémantique de valeur. Il suffit qu'il soient copiables (je suis pas sûr pour le constructeur par defaut).