Discussion :

[TNT89]

(Re)Bonjour,

J'ai des petits soucis concernant les templates... de templates . 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 :

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
 
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 :

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

Merci de votre aide.

[screetch]

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
//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 :

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

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)

[Matthieu Brucher]

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

[crazyvirus]

Corriger moi si je me trompe ! Les templates c en c++ ?
c'est pas dotnet ou quelque chose comme ca ?

[screetch]

c'est quoi les template C ?

[Alp]

Il a voulu dire

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++.

[screetch]

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

[TNT89]

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

Oui ça fonctionne . 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é?

[Matthieu Brucher]

Non, ça indique seulement que le ::iterator est un type, et non une valeur.

[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?

[NiamorH]

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.

[TNT89]

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

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
 
   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?

[Matthieu Brucher]

C'est quoi l'erreur ?

[TNT89]

./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.

[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.

[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 :

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

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...

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?

[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.

[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...

[babar63]

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

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...

[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. ?