Discussion :

[chubinou]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[NiamorH]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[screetch]

ca ne marche pas mieux, c'est toujours le meme probleme :-/

[NiamorH]

Ah bon, le code ne compile pas chez toi ? Ou alors j'ai mal compris le but recherché.

[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

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.

[Alp]

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

Quelque chose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[chubinou]

merci ca a l'air de marcher

[NiamorH]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}