Discussion :

[deubelte]

bonjour
pour continuer sur les template et metafonctions, dans le livre de Abrahams, on définit à la page 44 une Metaclass:

Code :

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

1
2
3
4
5
6
7
8
9
 
struct plus_f{
template<class T1,class T2>
struct apply
{
typedef typename mpl::plus<T1,T2>::type type;
};
 
};

comment peut-on accéder à T1 et T2?
comment le type template apply sera instanciée, et avec quelles valeurs de T1 et de T2?

Je vous remercie.

[TNT89]

A partir d'où veux-tu accéder à T1 et T2?

Généralement, je suis pour ma part plus tenté par l'écriture :

Code :

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

1
2
3
4
5
6
7
8
9
10
struct plus_f
{
    template<class T1,class T2>
    struct apply
    {
        typedef T1 Type1;
        typedef T2 Type2;
        typedef typename mpl::plus<T1,T2>::type type;
    };
};

Ce qui permet de camoufler de façon légère le type passé en paramètre (si besoin, pour une lecture...)...

Pour accéder à l'objet apply tu peux faire :

Code :

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

plus_f::apply<T1, T2> inst;

[guillaume07]

comment est codé mpl::plus ?

[Flob90]

Regarde la doc de MPL tu pourras avoir une idée du fonctionnement si tu connais un peu le fonctionnement de base de la méta-prog.

Sans en être certains, mpl::plus va matcher chacun de ces paramètres template avec un type représentant un entier pour pouvoir définir un nouveau type qui représente l'entier égal à la somme de tout les entiers.

Code :

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

1
2
3
4
5
6
7
 
template<size_t t> struct integral
{ enum { value = t }; };
 
template<class A, class B>
struct plus
{ typedef integral<A::value + B::value> result; };

(C'est surment un truc du genre mais en beaucoup mieux )

[guillaume07]

oui voilà c'est ça! merci
le integral il me semble qu'il est définit via static const int et non enum...ça m'amène une question... qu'est ce que ça change ?
un exemple complet :

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
 
template<class A,class B, class C>
struct DoOp
{
	typedef typename C::template  apply<A,B>::type type;
};
 
template <int N>
struct int_
{
	static const int value = N;
};
 
template<class A, class B>
struct plus
{ 
	typedef int_< A::value +   B::value> type; 
};
 
 
struct plus_f
{
	template<class T1,class T2>
	struct apply
	{
		 typedef typename plus<T1,T2>::type type;
	};   
};
 
template<class A, class B>
struct minus
{ 
	typedef int_< A::value -   B::value> type; 
};
 
 
struct minus_f
{
	template<class T1,class T2>
	struct apply : minus<T1,T2>{};   //"forwarding" autre technique a priori meilleur
};
 
void main()
{
	std::cout << DoOp< int_<9>, int_<1>, plus_f>::type::value << "\n";
       std::cout << DoOp< int_<9>, int_<1>, minus_f>::type::value << "\n";
	std::cin.ignore();
}

[Joel F]

On n'accede jamais ni au parametres passés au appyl ni à appyl lui même.
Le apply n'est qu'un articifce du protocole de meta-fonctions.

Les meta-fonctions acceptents de IntegralConstant qui sont définies comme exposant un ::value et ::value_type dans leur interface. On calcule tout avec ça et on n'a pas a se préoccuper du reste.

Pour enum vs static const, ca remonte au temps ou certain compilo ne compilaient pas static const proprement

[guillaume07]

On n'accede jamais ni au parametres passés au appyl ni à appyl lui même.

Code :

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

1
2
3
4
5
6
template<class A,class B, class C>
struct DoOp
{
    typedef typename C::template  apply<A,B>::type type;
};

Un code comme ça ne doit pas exister ?

[Joel F]

Code :

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

1
2
3
4
5
6
template<class A,class B, class C>
struct DoOp
{
    typedef typename C::template  apply<A,B>::type type;
};

Un code comme ça ne doit pas exister ?

Non, on fait plutot :

Code :

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

1
2
3
4
 
template<class A,class B> 
struct DoOp : mpl::apply1<A,B>
{};

On passe par la lambda abstraction qui gère tout ça.

[guillaume07]

ok

[deubelte]

J'ai du mal a comprendre le code suivant:

Code :

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

1
2
3
template<class A,class B> 
struct DoOp : mpl::apply1<A,B>
{};

qu'on va simplier en

Code :

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

1
2
3
template<class A,class B> 
struct DoOp :apply1<A,B>
{};

C'est le type template DoOp, qui va hérité du type templaté apply1<A,B>.

Pour une classe ce serait l'équivalent de
class A:public B{}

mais ce qui me gène ici, c'est l'absence du mot clé public.

Merci

[Flob90]

Pour une struct l'héritage par défaut est publique, pour une classe c'est private. C'est la différence entre class et struct qui se retrouve aussi au niveau de la visibilité par défaut.