specialisation de fonction template

Version imprimable

bonjour j'ai un petit probleme de template, je souhaite specialiser une fonction template avec un type template

voici un exemple debile mettant en lumiere mon probleme

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
35
 
#include <list>
#include <iostream>
 
template<typename T> T plop(int i)
{
  return T();
}
 
template<> int plop<int>(int i)
{
  return i;
}
 
template<typename T>
std::list<T>
plop<std::list<T> >(int l)
{
  std::list<T> list;
  for (int i =0; i < l; i++)
    {
      list.push_back(plop<T>(i));
    }
  return list;
}
 
 
int main()
{
  std::list<int> l = plop<std::list<int> >(5);
 
  for (std::list<int>::iterator i = l.begin();
       i != l.end(); i++)
      std::cout << *i << std::endl;
}

et le compilo me retourne

Code:

1
2
3
4
5
6
 
test.cc:16: error: function template partial specialization ‘plop<std::list<T, std::allocator<_CharT> > >’ is not allowed
test.cc: In function ‘int main()’:
test.cc:30: error: call of overloaded ‘plop(int)’ is ambiguous
test.cc:4: note: candidates are: T plop(int) [with T = std::list<int, std::allocator<int> >]
test.cc:16: note:                 std::list<T, std::allocator<_CharT> > plop(int) [with T = std::list<int, std::allocator<int> >]

Je crois qu'il me dit que mes deux fonctions sont potentiellement acceptable puisqu'il ne voit pas le fait que std::list<T> est deja une specialisation

je ne sais pas comment corriger ca
merci d'avance pour votre aide

04/11/2007, 08h52
Jean-Marc.Bourguet

Il te dit surtout et pour commencer qu'on ne peut pas faire de spécialisation partielle de fonction template. Résouds ce problème-là -- on en a déjà parlé dans le passé -- et je crois que la deuxième erreur disparaîtra. Au pire, elle sera dans un contexte plus clair.

Salut,
personnellement, dans ton cas, je surchargerais plutôt que de spécialiser :

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
35
36
37
38
39
#include <list>
#include <iostream>
 
template<typename T> T plop(int i)
{
  return T();
}
 
template<> int plop<int>(int i)
{
  return i;
}
 
template<typename T, 
         template<typename ELEM,
                  typename ALLOC > 
         class CONT>
CONT<T, std::allocator<T> >
plop(int l)
{
  CONT<T> list;
  for (int i =0; i < l; i++)
    {
      list.push_back(plop<T>(i));
    }
  return list;
}
 
 
int main()
{
  std::list<int> l = plop<int, std::list>(5);
 
  for (std::list<int>::iterator i = l.begin();
       i != l.end(); i++)
      std::cout << *i << std::endl;
 
  return 0;
}

Tu as comme ça une fonction qui accepte n'importe quel conteneur qui implémente push_back

04/11/2007, 12h18
screetch

ca ne marche pas mieux, c'est toujours le meme probleme :-/
04/11/2007, 13h09
NiamorH

Ah bon, le code ne compile pas chez toi ? Ou alors j'ai mal compris le but recherché.
05/11/2007, 00h14
chubinou

en effet ca ne compile pas non plus chez moi.

le code que j'utilise reellement a pour objectif de faire de la serialisation, deserialisation de donné via un systeme de template. Pour le moment la serialisation marche sans probleme, mais j'ai des soucis sur la deserialisation.

grosso modo voila a quoi mon code ressemblera a la fin

typedef std::list<std::pair<int, float> > MonType;

Data d = marshal(foo); //avec foo de type MonType, ca ca marche pour le moment
Montype bar = unmarshal<Montype>(d);

donc mon probleme est que ma fonction unmarshal doit pouvoir etre template aussi bien avec des int qui ne sont pas template que avec des listes qui ont 1 parametre template ou avec des pairs qui en ont deux

Citation:

Résouds ce problème-là -- on en a déjà parlé dans le passé -- et je crois que la deuxième erreur disparaîtra

J'ai pas vu comment (ou du moins, j'ai rien vu qui ne s'approche de mon probleme)

sinon j'ai pensé qu'une solution de mon proleme pourait etre de passer mon objet de retour en reference, ainsi ce ne serait plus qu'un probleme de surchage. Mais j'aimerais bien quand meme savoir (histoire de ne pas mourir idiot) quel est la solution propre a ce probleme

PS: desolé si je met du temps entre mes reponses, je finnirais par repondre.

Tu ne peux pas spécialiser une fonction template, mais tu peux le faire sur une structure ... ;)

Quelque chose comme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 template <typename Type> struct unmarshal { static Type Do (const Data& d) { // code "générique" } }; template <> struct unmarshal<int> { static int Do (const Data& d) { // code pour int ... } } // etc ...
Cela ne convient pas ?

05/11/2007, 14h38
chubinou

merci ca a l'air de marcher

Il manquait simplement un std::allocator<T> pour que ça compile correctement. VS2003 ne me signalait pas l'erreur.

Ce code-ci devrait passer sans problème :

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
35
36
37
38
39
#include <list>
#include <iostream>
 
template<typename T> T plop(int i)
{
  return T();
}
 
template<> int plop<int>(int i)
{
  return i;
}
 
template<typename T, 
         template<typename ELEM,
                  typename ALLOC > 
         class CONT>
CONT<T, std::allocator<T> >
plop(int l)
{
  CONT<T, std::allocator<T> > list;
  for (int i =0; i < l; i++)
    {
      list.push_back(plop<T>(i));
    }
  return list;
}
 
 
int main()
{
  std::list<int> l = plop<int, std::list>(5);
 
  for (std::list<int>::iterator i = l.begin();
       i != l.end(); i++)
      std::cout << *i << std::endl;
 
  return 0;
}