spécialisation d'une fonction template pour pointeurs

Bonjour,

dans le cadre d'un petit outil pour le binding Js <=> C++, je voudrais écrire une fonction template pour convertir différents types natif depuis et vers JS.

J'ai donc un template par défaut défini comme suit (1):

Code:

---

1 2 3 4 5

template<typename TYPE> TYPE JsToNative(JsObj object) { throw new Exception("unhandled JsToNative conversion."); }

---

Je spécialise ensuite ce template pour différents types de base (int, string, ...). Les paramètres d'entrées restent identique (JsObj) ; seul celui de retou diffère. Par exemple (2):

Code:

---

1 2 3 4 5 6 7 8

template<> std::string JsToNative(JsObj object) { if (object.isJsString()) return std::string(object.toString()); else throw new Exception("bad JsToNative conversion: JS object is not a string."); }

---

Mon problème est que je voudrais maintenant définir une spécialisation 'générique' qui s'applique pour tout TYPE qui soit un pointeur vers une instance de classe. Quelque chose comme (3):

Code:

---

1 2 3 4 5 6 7 8 9 10

template<> TYPE* JsToNative(JsObj object) { if (object->isJsObject()) { TYPE* ptr = dynamic_cast<TYPE*>( object->getBoundDataPointer() ); if (ptr) return ptr; } throw new Exception("bad JsToNative conversion: JS object is not bound to a native instance."); }

---

Problème: cette dernière implémentation (et les autres variantes testées) ne fonctionnent pas quand j'essaie de lui passer un pointeur ( JsToNative<MonType*>(myJsObj) ) : soit le compilo essaie d'utiliser (1) à la place de (3), soit j'ai un "call of overloaded template function is ambiguous".

Une idée ?

Merci d'avance :D

On ne peut pas faire de spécialisation partielle pour des fonctions templates.
Mais tu peux faire une pirouette en utilisant une classe :

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 34

template<typename TYPE> TYPE JsToNative(JsObj object) { return JsToNativeImpl<TYPE>::Convert(object); }   template<typename TYPE> class JsToNativeImpl; // Note : il vaut mieux ne pas donner d'implémentation par défaut. // En faisant ça, on obtient une erreur dès la compilation si on veut convertir // un type Java en un type natif non supporté (au lieu d'une exception au runtime).   template<> class JsToNativeImpl<std::string> { public : static std::string Convert(JsObj object) { if (object.isJsString()) return std::string(object.toString()); else throw new Exception("bad JsToNative conversion: JS object is not a string."); } };   template<TYPE> class JsToNativeImpl<TYPE*> { public : static TYPE* Convert(JsObj object) { if (object->isJsObject()) { TYPE* ptr = dynamic_cast<TYPE*>( object->getBoundDataPointer() ); if (ptr) return ptr; } throw new Exception("bad JsToNative conversion: JS object is not bound to a native instance."); } };

---

Edit : correction du code (cf. post suivant).

Merci pour ta réponse rapide. A une ou deux typos près (forward déclaration de la classe, fonction statique publique, ...) c'est juste parfait. :ccool:

Une petite question subsidiaire au passage ; l'utilisation de struct en lieu et place d'une classe poserait-elle un problème ?

De rien !

Citation:

---

Envoyé par nouknouk

Une petite question subsidiaire au passage ; l'utilisation de struct en lieu et place d'une classe poserait-elle un problème ?

---

Pas du tout. J'ai tapé le code ci-dessus un peu vite, mais en temps normal j'aurai effectivement utilisé struct, juste pour éviter d'avoir à écrire le public : (que j'avais effectivement oublié ;)).