Template, spécialiser fonction pour paramètre template

Bonjour

Je me heurte à une colle :

Code:

---

1 2	template< class SRC, class DST> void to(const SRC& src, DST& dst);

---

Pour les spécialiser, aucun souci, jusqu'à ce que SRC et DST eux-même soient class template.

Code:

---

1 2	template<> void to<>(const std::vector<T>& src, Framework::Array<N>& dst);

---

J'ai essayé toutes les positions imaginables sauf la bonne :cry:

la spécialisation to<T,N> existe déjà.

Il faut faire une version où SRC et DST sont des templates de templates.
Voire 4 en tout si tu envisages toutes les possibilités...

Fait une surcharge template et pas une spécialisation template (qui ne peuvent être que totale au passage) :

Code:

---

1 2 3

template<class T, size N> void to(const std::vector<T>& src, Framework::Array<N>& dst);

---

Après ma solution ne convient peut-être pas idéal, regardes aussi du côté des technique de tag dispatching, ça peut correspondre. L'idée est de pouvoir récupérer un type tag depuis les paramètres de ta fonction, pour ainsi pouvoir dispatcher sur la bonne fonction en utilisant des surcharges correspondants aux différents tag :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

struct tag_simple {}; struct tag_containor {};   template<class T> struct tag_trait;   template<class T> void foo_impl(T t, tag_simple) { /*...*/ }   template<class T> void foo_impl(T t, tag_containor) { /*...*/ }   template<class T> void foo(T t) { typedef typename tag_trait<T>::type tag; return foo_impl(t,tag()); }

---

En codant le tag_trait qui convient pour déterminer le tag en fonction du type.

Pour un article sur le sujet, regardes sur le site de boost (faut fouiller un peu par contre :s).

:salut:

Es-tu sur d'avoir besoin de donner explicitement les types de conteneurs ? Tu ne peux pas travailler directement avec les concepts et le SFINAE ?

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

template <class SRC, class DST> void to(const SRC& src, DST& dst) // I { }   template <class SRC, class DST> void to(const SRC& src, DST& dst) // II { // utilise le concept de conteneur compatible STL // test l'existence de src.begin(), src.end(), dst.begin(), dst.end() using SRC::begin(); using SRC::end(); using DST::begin(); using DST::end(); }   template <class SRC, class DST> void to(const SRC& src, DST& dst) // III { // utilise le concept de conteneur à accès aléatoire compatible STL // test l'existence de src.begin(), src.end(), dst.begin(), dst.end() // test l'existence de src[], dst[] using SRC::begin(); using SRC::end(); using DST::begin(); using DST::end(); using SRC::operator[] (size_type n); using DST::operator[] (size_type n); }   to(vector, array); // utilisera la spécialisation III to(vector, list); // utilisera la spécialisation II to(vector, myContainer); // version générique I

---

En gros, la question est : as-tu besoin d'avoir précisément les types vector et array (ce qui signifie que tu devras donner une spécialisation pour presque toutes les combinaisons possibles), ou tu as juste besoin de spécialiser la fonction en fonction des concepts utilisés ("posséder les fonctions begin et end", "posséder l'opérateur []", etc) ?

Bien vu gbdivers, je n'avais pas pensé à ça.
Par contre j'ai eu l'erreur suivante

Citation:

---

error C2885: 'std::vector<_Ty>::operator []': not a valid using-declaration at non-class scope

---

Dommage, j'aimais beaucoup le concept.

J'ai déjà plusieurs spécialisations de types plus simples, mais ces containers voulaient pas passer (ce sont les seuls containers, ouf :aie:).

J'avais aussi testé

Code:

---

1 2	template<class T, class N> void to(const std::vector<T>& src, Framework::Array<N>& dst)

---

qui me renvoyait une jolie insulte à l'édition des liens: error LNK2001: unresolved external symbol.

En déplaçant sa déclaration avant son utilisation, ça fontionne. 8O

Merci :ccool:

J'espère que tu n'as pas copier mon code tout moisi :)
Pour faire plus propre, il faudrait probablement utiliser des static assert, des enable_if, bref, utiliser type_traits (C++11 ou boost)

EDIT : je viens de relire mon code... comment j'ai pu écrire un truc pareil... Aucune chance que ça fonctionne :aie: Faut que j'arrête d'écrire du code trop tôt le matin

Oui j'y croyais au coup des using, même si je me demandais comment diable il pouvait deviner quelle fonction utiliser. :mouarf:

Du coup le problème est réglé : je n'ai ni C++11 ni Boost.:aie:

Mais le plus fou c'est la résolution : mon code fonctionnait, j'ai juste eu à le remonter d'une dizaine de lignes dans le fichier.:aie: