Comment redéfinir une fonction template ?

Salut,

Je possède deux sorte d'objets à sérialzizer :

-Les types primitifs (int, double, etc...)
-Les objets.

Les types primitif sont inséré tel quel dans les objets ostream et istream.
Les objets sont sérializé à l'aide d'une méthode que je défini dans la classe même et elle prend en argument une archive contenant le stream qui se charge de compresser/décompresser les données.

Pour sérializer un type primitif j'ai redéfini l'opérateur & dans les classes Archive.

Le problème est que j'ai besoin de une redéfinition pour les types primitifs et une autre pour les objets :

Code:

---

1 2 3 4 5 6 7 8 9

template <typename T> void operator& (Serialize<T>& object) { objet.serialize(*this); } template <typename T> void operator& (T& data) { buffer<<data; }

---

Si c'est un type primitif je dois le mettre dans le stream, sinon je dois ré-appeler la méthode sérialize sur l'objet.

Le problème est que il me met toujours l'erreur que l'opérateur << n'existe pas pour l'objet, c'est normal après tout, je l'ai pas défini car je peux pas le sérialiser directement dans l'archive.

Alors ce que je voudrais c'est redéfinir la méthode de manière à ce que je n'ai plus cette erreur en compilation mais je ne vois pas très bien m'y prendre.
J'ai entendu parlé de sf finae mais je n'ai pas trouvé grand chose là dessus.

Merci d'avance pour vos réponses.

Bon j'ai défini un autre opérateur pour la sérialisation d'objets ou bien de tableaux d'objets. (L'opérateur | )

J'ai essayé sffinae mais même avec ça il va dans la mauvaise fonction et m'indique toujours l'erreur de compilation comme quoi il n'y pas d'opérateur<< pour les objets de type Serializer<O>.

Mais si quelqu'un à une meilleur solution je suis preneur.

Merci d'avance.

Salut !

C'est tout à fait possible. Par exemple avec 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

#include <iostream> #include <type_traits>   struct Object { void serialize() {}; };   template <typename T, class = typename std::enable_if<std::is_member_function_pointer<decltype(&T::serialize)>::value>::type> void f (T& object) { std::cout<<"object version"<<std::endl; }   template <typename T, class... D, class = decltype(std::declval<std::ostream>()<<std::declval<T>()), class = typename std::enable_if<!sizeof...(D)>::type> void f (T& data, D...) { std::cout<<"data version"<<std::endl; }   int main() { Object o{}; int i = 42; f(o); f(i); return 0; }

---

La première version est appelée si l'objet possède une fonction membre serialize. La seconde est appelée si la data est sérializable via l'opérateur << sur un std::ostream. Dans le cas où un objet satisferait les deux, j'utilise un trick perso à base de variadic template pour mettre une priorité moins importante sur la seconde fonction. Problem solved à mon avis... Ca convient ?

Ha ok je vais essayé ça, j'avais essayé la méthode trouvée dans la FAQ mais ça n'avais pas marché.

Merci. :)

Bon j'ai essayé ta technique mais malgré ça le compilateur me choisi toujours la mauvaise fonction c'est à dire la deuxième au lieu de la 1ère lorsqu'il doit sérializer des objets.

Code:

---

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

template <typename O, class = typename std::enable_if<std::is_member_function_pointer<decltype(&O::serialize)>::value>::type> void operator() (O& object) { std::cout<<"Serialize"<<std::endl; object.serialize(*this); } template <typename T, class... D, class = decltype(std::declval<std::ostream>()<<std::declval<T>())/*,   class = typename std::enable_if<!sizeof...(D)>::type*/> void operator() (T& data, D...) { std::cout<<"Serialize int"<<std::endl; buffer<<data; }

---

Il m'affiche toujours serialize int. (Même lors de la sérialization d'objets)

Est ce normal ?

Sinon ma fonction serialize est template, n'est ce pas cela qui pose problème ?

Et-tu sûr d’appeler correctement la fonction ? Le code de Kaluza fonctionne parfaitement.

Citation:

---

Et-tu sûr d’appeler correctement la fonction ?

---

Oui.

Ca doit sûrement être parce que ma fonction serialize prend un paramètre template alors..., son prototype est inconnu en compilation donc, ça m'étonnerait qu'il puisse évaluer correctement son type c'est un peu comme avec le polymorphisme.

Car en effet le code qu'il m'a proposé fonctionne bien lui.

Ouais c'est bien ce que je pensais si je rajoute ça :

Code:

---

1 2 3

template <typename A> void serialize(A archive) {};

---

Le code ne fonctionne plus, il va toujours dans "data version".

Essaye avec cette version:

Code:

---

1 2 3 4 5

template <class T, class = decltype(std::declval<T&>().serialize(std::declval<Archive&>()))> void f (T& object) { std::cout<<"object version"<<std::endl; }

---

Super ça marche!!!!

Merci!!!! :D

Ça m'a l'air :
- Complexe
- Différent des specs initiales.

Les specs initiales différenciaient type de base et type objet, mais là, on différencie type ayant une fonction membre serialize de type n'en ayant pas. On risque donc fort d'avoir du code qui compile, qui s'exécute, mais qui n'est pas capable de recharger les fichiers sauvés.

J'aurais défini une fonction non template pour chacun des types de base à sauver (*), et une fonction template pour les autres types, qui utilise la fonction membre, ainsi, si on tente de sérialiser une classe non conforme, on a une belle erreur de compilation.

(*) Ou éventuellement un template sélectionnant uniquement les types de base à l'aide de std::is_fundamental...

Ha, ok. ^^