Template et fonctions

Bonsoir,

Je suis en train de faire un wrapper d'une bibliothèque dans le cadre d'un projet, cependant je me heurte à un petit soucis avec les templates. Je ne sais pas vraiment caractériser ce problème par des mots, je vais donc d'abord montrer le code source de ce que j'ai fais.

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

/** vec    * \brief Mathematics vectors.    */ template <unsigned int Dim, typename T> struct vec;   template <typename T> struct vec<2, T> { typedef glm::detail::tvec2<T> value; typedef glm::detail::tvec2<T> const& const_ref; };   template <typename T> struct vec<3, T> { typedef glm::detail::tvec3<T> value; typedef glm::detail::tvec3<T> const& const_ref; };   template <typename T> struct vec<4, T> { typedef glm::detail::tvec4<T> value; typedef glm::detail::tvec4<T> const& const_ref; };

---

Voici donc la définition de ma classe vector en utilisant la bibliothèque GLM. Maintenant, toujours dans le but de m'éviter de ré-écrire les fonctions, j'ai voulu écrire un wrapper pour la fonction cross product. Cela donne donc:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

/** Compute the cross product between two vectors.    * \param left Left vector.    * \param right Right vector.    * \return Cross product between left and right.    */ template <unsigned int Dim, typename T> typename vec<Dim, T>::value cross_product( typename vec<Dim, T>::const_ref left , typename vec<Dim, T>::const_ref right) { return glm::cross(left, right); }

---

Maintenant pour plus de facilité j'ai fais quelque typedefs:

Code:

---

1 2 3 4

// 3d vector typedefs. typedef vec<3, double>::value vec3d; typedef vec<3, float>::value vec3f;

---

Et donc, l'utilisation qui ne fonctionne pas:

Code:

---

1 2 3 4 5

vec3f v0 = vec3f(1.f, 0.f, 0.f); vec3f v1 = vec3f(0.f, 1.f, 0.f);   vec3f res = cross_product(v0, v1);

---

L'erreur étant, je trouve, assez obscure puisque je ne vois pas vraiment où le compilateur veut en venir car pour moi les types sont équivalents:

Code:

---

1 2 3 4 5

Programming/Project/wind/src/demo/main.cxx: In function ‘int main()’: Programming/Project/wind/src/demo/main.cxx:37:35: error: no matching function for call to ‘cross_product(wind::math::vec3f&, wind::math::vec3f&)’ Programming/Project/wind/src/demo/main.cxx:37:35: note: candidate is: Programming/Project/wind/include/wind/math/vector.txx:30:55: note: template<unsigned int Dim, class T> typename wind::math::vec::value wind::math::cross_product(typename wind::math::vec<Dim, T>::const_ref, typename wind::math::vec<Dim, T>::const_ref)

---

Je pense que l'erreur doit être stupide, mais là j'avoue ne vraiment pas voir.
Est-ce quelqu'un pourrait me donner un petit coup de main ?

Merci d'avance! :-)

http://codepad.org/9SslObrb

Citation:

---

Envoyé par ponce

http://codepad.org/9SslObrb

---

Bonjour,
il veut faire un wrapper sans avoir à recoder le cross product etc...
(qui d'ailleurs est suspect dans le lien : remplacement de produit par des soustractions)

Pour le problème de Kiwei je ne vois pas trop, rien ne me choque. Il va falloir attendre des yeux plus avisés.

Salut,

Merci beaucoup, l'erreur était en effet assez triviale.
Encore merci pour le temps que tu as accordé à me répondre! :)

Par contre, ce qui m'embète c'est qu'il faut spécifier les arguments templates de la fonction. Or, j'espérais (à tord j'avoue) que le compilateur aurait déterminé seul ces derniers. Bon je me rend bien compte au final que c'est en effet pas possible en l'état. mais est-ce que vous auriez une solution élégante ?

Je n'ai pas de solution élégante, j'ai juste changé des choses au hasard jusqu'à ce que ça marche :)
Et du coup il a fallu refaire un cross-product (oups, faux en plus) pour simuler glm.
EDIT: une autre solution serait de faire tes propres small vectors puis de spécialiser vec pour convertir implicitement vers les type glm + un constructeur implicite à partir d'un type glm). Enfin, facile à dire.

Essai de spécifier ton appel à cross_product :

Code:

---

vec3f res = cross_product<3,float>(v0, v1);

---

Chez moi ça marche, mais je ne comprend pas pourquoi il ne trouve pas tout seul.


Edit :

Sinon il y a cette solution :

Code:

---

1 2 3 4 5 6 7 8 9

//changement de ton cross product template <typename VecType> VecType cross_product( const VecType& left ,const VecType& right) { return glm::cross(left, right); }

---

et plus loin

Code:

---

vec3f res = cross_product(v0, v1);

---

là il comprend tout seul.

Bonsoir,

Le problème est que le compilateur ne peut pas déduire les arguments templates si ceux si sont dans un nom qualifié (ie A<T>::B -> T ne peut pas être déduit). Mets toi à la place du compilateur, si l'argument est A<T> et que l'objet est de type (statique) A<int> alors l'identification du type T est direct (T = int), si maintenant l'argument est A<T>::B, et que l'objet est de type A_IMPL<T>, comment je fais ? Ce n'est pas impossible, mais ce n'est plus une simple identification (il faudrait passer tout les types définient à cette instant dans l'unité de traduction jusqu'à ce que A<T>::B = A_IMPL<T> et en espérant qu'il n'y ai pas de collision ! (*) ). Le C++ ne permet pas ce genre de "déduction".

Je trouve étrange que ton produit vectoriel travail avec la classe représentant les détails d'implémentations, autrement dit ce que tu voulais enrober. Pourquoi ne pas prendre en argument un Vect<Dim,T> et laisser le soin à Vect<Dim,T> d'avoir un sous-objet qui représente les détails d'implémentation ?

Sinon sous certaines conditions (à chaque classe représentant l'implémentation on peut associer une unique classe d'enrobage), on peut réaliser une classe de traits qui a chaque classe représentant les détails d'implémentation associe la classe d'enrobage. Et ensuite utiliser une fonction de produit vectoriel intermédiaire qui prend en argument un const T& et qui appele la seconde fonction de produit vectorielle en spécifiant les paramètres templates grace à la classe de trait. (**)

(*) Et potentiellement d'autres problèmes auquels je ne pense pas.
(**) Je ne suis pas convaicu de l'apport d'une telle solution. Dans les deux cas on a un indirection (pour accéder au sous-objet dans le premier cas et l'utilisation d'une fonction intermédiaire dans l'autre), et personnelement je préfère la première solution.