A propos des Templates

Version imprimable

(Re)Bonjour,

J'ai des petits soucis concernant les templates... de templates :lol:. Pour faire simple, j'ai une classe Vector< TYPE_UTILISE, NB_DIMENSION > que je dois passer en template de classe dans une autre structure AutreStruct< class C, [...]>. Je voudrais reconnaitre alors la structure Vector de deux manières : quelque soient TYPE_UTILISE et NB_DIMENSION et, ensuite, quelque soit NB_DIMENSION en sachant que tout cela se passe au niveau d'une fonction...

Pour éclaircir :
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 template<typename TYPE, int DIMENSION> struct Vector { typedef TYPE* iterator; //blabla... }; template< class C1, class C2> struct AutreStruct { //blabla }; //Le problème est ici : //La fonction de base template< class T, class U> AutreStruct< T, U> MaFonction( const T &t, const U &u) { //blabla } //La spécialisation qui ne fonctionne pas //C'est le premier cas qui m'intéresse ici, puisque la fonction ne doit juste //reconnaitre que le type Vector et peu importe le nombre de dimensions //ou le type utilisé template<class U> template<typename TYPE, int DIMENSION> AutreStruct< Vector<TYPE, DIMENSION>::iterator , U> MaFonction( const T &t, const U &u) { //blabla }
Erreur retournée par GCC :

Citation:

error: type/value mismatch at argument 1 in template parameter list for `[...]'

Merci de votre aide.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//Le problème est ici :
      //La fonction de base
template< class T, class U>
AutreStruct< T, U> MaFonction( const T &t, const U &u)
{
      //blabla
}
 
      //La spécialisation qui ne fonctionne pas
      //C'est le premier cas qui m'intéresse ici, puisque la fonction ne doit juste
      //reconnaitre que le type Vector et peu importe le nombre de dimensions
      //ou le type utilisé
template<class U, typename TYPE, int DIMENSION>
AutreStruct< Vector<TYPE, DIMENSION>::iterator , U> MaFonction< Vector<TYPE, DIMENSION>::iterator , U>( const Vector<TYPE, DIMENSION>::iterator &t, const U &u)
{
      //blabla
}

la syntaxe est :

Code:

1
2
3
4
5
6
7
8
9
10
 
template<typename t1, typename t2>
void fonction();
 
template< typename t, int dimension, ..... >
void fonction< t1, t2 > ();
/* remplacer t1,t2 par le type auquel correspond la specialisation
soit dans ton exemple */
template< typename t, int dimension, typename u >
void fonction< Vector<t,dimension>,u > ();

ensuite dans ta specialisation, T et U ne sont pas connus, il faut recopier le type specialisé (vector....::iterator)

20/02/2008, 23h14
Matthieu Brucher

Vector<TYPE, DIMENSION>::iterator -> typename Vector<TYPE, DIMENSION>::iterator ?
21/02/2008, 01h10
crazyvirus

Corriger moi si je me trompe :) ! Les templates c en c++ ?
c'est pas dotnet ou quelque chose comme ca ?
21/02/2008, 08h11
screetch

c'est quoi les template C ?
21/02/2008, 08h22
Alp

Il a voulu dire

Citation:

les templates c'est en C++ ?

A l'origine c'est du C++.
Il y a quand même quelque chose de similaire en C# et en Java (les Generics).

Mais tout ce qui est abordé ici, ce sont les templates du C++.
21/02/2008, 09h25
screetch

ah! ok. bon je retourne sur MSN apprendre ce langage bizarre
21/02/2008, 10h26
TNT89

Citation:

Envoyé par Matthieu Brucher

Vector<TYPE, DIMENSION>::iterator -> typename Vector<TYPE, DIMENSION>::iterator ?

Oui ça fonctionne :king:. Mais, corrigez moi si je me trompe, ça revient à faire du template typedef ???

On doit donner aussi tous les paramètres de template dans la version générale? Si oui, imaginons que je veuille utiliser cette surcharge pour fonctionner avec des matrices, ça va me donner des listes à rallonge non? C'est plutôt bien supporté?
21/02/2008, 10h27
Matthieu Brucher

Non, ça indique seulement que le ::iterator est un type, et non une valeur.
21/02/2008, 10h44
TNT89

Y aurait-il une possibilité de faire des listes de paramètres template pour améliorer la lisibilité du code? Ou des structures qui s'y rapprochent?
21/02/2008, 11h37
NiamorH

Citation:

Envoyé par screetch

ah! ok. bon je retourne sur MSN apprendre ce langage bizarre

J'ai mis 10 bonnes secondes à comprendre que tu n'avais pas écrit MSDN.

Je 'up' un peu, mais j'ai encore une question syntaxique dans le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
   template<bool VALUE>
   struct RecoFlag
   {
           const static bool Value = VALUE;
   };
 
   // Le cas de base pour la reconnaissance de deux vecteurs de même dimension. Ici pas de problème
   template<
                    template<typename TYPE1, int DIM1> class A,
                    template<typename TYPE2, int DIM2> class B
               >
   struct Correspondance : public RecoFlag<false>
   { };
 
    //La spécialisation de la classe précédente, qui ne fonctionne pas, ce sont les déclarations des templates "template<typename TYPEX, int DIMX> Vect<TYPEX, DIMX>" qui poseraient problème
    template< >
    struct Correspondance< template<typename TYPE1, int DIM1>  Vect<TYPE1, DIM1>,
                           template<typename TYPE2, int DIM2> Vect<TYPE2, DIM2>
                         > : public RecoFlag< DIM1==DIM2 >
        { };

Le compilateur ne semble pas apprécier ce genre d'écriture, que puis-je faire?

22/02/2008, 13h41
Matthieu Brucher

C'est quoi l'erreur ?
22/02/2008, 13h50
TNT89

Citation:

./header.h:51: error: missing `>' to terminate the template argument list
./header.h:51: error: wrong number of template arguments (1, should be 2)
./header.h:47: error: provided for `template<template<class TYPE1, int DIM1> class A, template<class TYPE2, int DIM2> class B> struct Correspondance'

et la ligne 51 est celle de la spécialisation de Correspondance.
22/02/2008, 13h53
Matthieu Brucher

Un peu normal, TYPE1, TYPE2, DIM1 et DIM2 sont des paramètres template, non ?
De plus, il y a un problème avec le DIM1==DIM2 puisque dans le cas où c'est faux, il y a redéfinition du template avec false.

Pose ton problème de manière plus simple, sans l'imbrication des templates. Une fois que ça marche, tu peux ajouter une hiérarchie, mais tant que la base ne fonctionne pas, ne complexifie pas.
22/02/2008, 14h00
TNT89

Le problème est que je suis obligé d'utiliser des template de template car sinon je dois utiliser une déclaration linéaire de tous ces paramètres du style :

Code:

template< typename TYPE1, typename TYPE2, int DIM1, int DIM2, ...>

9a me pose un gros problème : je dois passer les paramètres un par un alors qu'ils sont contenus dans un Vect<TYPEX, DIMX> qui est reconnu automatiquement par la fonction qui reçoit les objets en arguments...

Citation:

De plus, il y a un problème avec le DIM1==DIM2 puisque dans le cas où c'est faux, il y a redéfinition du template avec false.

Et si j'essaie de faire deux spécialisation?
22/02/2008, 14h03
Matthieu Brucher

Commence par faire un template plus simple, sans le type complexe Vect<>. Si tu commences par quelque chose de trop compliqué, ça ne marchera pas et tu ne comprendras jamais comment utiliser les templates proprement.
22/02/2008, 14h07
TNT89

Ok merci je vais tenter de faire des choses plus simples avec les templates, enfin je connais les bases mais j'ai toujours des problèmes sur quelles informations sont connus du compilo et à quel endroit pour ce genre de prog...
22/02/2008, 14h33
babar63

Citation:

je connais les bases mais j'ai toujours des problèmes sur quelles informations sont connus du compilo et à quel endroit pour ce genre de prog...

Je pense que tout le monde passe par la (enfin pour ma part c'est le cas) Le mieux c'est la pratique... et comme te la dit Matthieu Brucher, commence par faire simple, une fois que les bases seront bien acquises et lorsque tu commenceras à cerner "un peu" mieux les possibilitées tu pourras commencer par faire des choses farfelues et te casser la tête sur les templates :yaisse2:

Citation:

Y aurait-il une possibilité de faire des listes de paramètres template pour améliorer la lisibilité du code? Ou des structures qui s'y rapprochent?

Une fois que ton code fonctionnera tu peux regarder du coté du rebinding si ça t'intéresse : http://alp.developpez.com/tutoriels/templaterebinding/, cependant il faut faire attention le code peut également s'alourdir parfois... donc à voir...;)
22/02/2008, 15h29
TNT89

Ok, merci.

Je suis intéressé par la métaprog en fait et j'aimerais savoir comment on peut s'assurer que le compilateur à bien fait le travail comme par exemple sur ce tutoriel avec l'exemple des calculs vectoriels... Comment peut on voir que le code "final" ne comporte plus toutes les classes intermédiaires d'opérateurs etc. ?
22/02/2008, 17h38
babar63

Pas bien loin il y a un autre tutoriel ;) je ne sais pas si c'est ce que tu cherches mais il y à une section traitant sur la sortie assembleur à la fin
22/02/2008, 17h59
TNT89

Citation:

Envoyé par babar63

Pas bien loin il y a un autre tutoriel ;) je ne sais pas si c'est ce que tu cherches mais il y à une section traitant sur la sortie assembleur à la fin

C'est une piste oui merci...mais j'utilise Code::Blocks et je ne sais pas s'il y a un équivalent... :?
22/02/2008, 18h01
Matthieu Brucher

Non, pas vraiment. GCC a le chic pour perdre une bonne partie de ce type d'information.
De toute manière, le compilateur n'a aps le choix, il doit calculer les valeurs, il ne délègue pas cela à l'exécution.
22/02/2008, 18h16
Alp

L'option -S de g++ permet d'avoir la sortie ASM.
22/02/2008, 18h24
TNT89

Je cite "Compiler Flags"

Citation:

Strip all symbols from binary (minimize size) [-s]
22/02/2008, 18h24
Matthieu Brucher

C'est pour ça qu'il a mis une majuscule.
22/02/2008, 18h54
TNT89

Oups, désolé...
Merci :D
22/02/2008, 19h07
Alp

C'est pas grave :)

Par contre le code ASM est parfois immonde... Il faut vraiment savoir ce qu'on cherche pour s'y retrouver :aie:

Je suis désolé de relancer ce topic mais j'ai une peite question sur la spécialisation partielle de fonction template. Je sais ça n'est pas autorisé par la norme mais je voudrais savoir s'il y a des inconvénients à ce genre de méthodes pour outre-passer l'interdiction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 template< int i1, int i2> struct ACLASS { inline static int AFUNCTION(int blabla) { return blabla + i1 + i2; } }; template< int i2> struct ACLASS<10, i2> { inline static int AFUNCTION(int blabla) { return blabla - 10 + i2; } };
et son appel dans main par exemple :
Code:

1 2 3 std::cout << ACLASS<10, 10>::AFUNCTION(10) << std::endl; std::cout << ACLASS< 9, 10>::AFUNCTION(10) << std::endl;

23/02/2008, 21h17
NiamorH

Non, c'est juste + long à écrire.