Discussion :

[méphistopheles]

Bonjour.

J'ai récemment écrit la classe de wrapper simple suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
template <class Wrapped>
class Wrapper : public Wrapped
{
  public:
  Wrapper():Wrapped(){}
  template <class T>
  Wrapper(T t):Wrapped(t)
  {
     char u;//juste pour déclencher un warning. 
  }
};

j'essaye ensuite d'exécuter ce code:

Code :

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

1
2
3
4
5
6
7
8
9
 
int main()
{
  std::string s;
  char f[32]="dummy"
  Wrapper<std::string> u(s);
  Wrapper<std::string> v("foo");
  Wrapper<std::string> w(f);
}

quand je regarde le message du compilo, j'ai:

-------------- Build: Debug in Boost_Serialize_Test ---------------

Compiling: main.cpp
/.../main.cpp: In constructor ‘Wrapper<Wrapped>::Wrapper(T) [with T = std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Wrapped = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’:
/.../main.cpp:103: instantiated from here
/.../main.cpp:39: warning: unused variable ‘u’
/.../main.cpp: In constructor ‘Wrapper<Wrapped>::Wrapper(T) [with T = const char*, Wrapped = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’:
/.../main.cpp:104: instantiated from here
/.../main.cpp:39: warning: unused variable ‘u’
/.../main.cpp: In constructor ‘Wrapper<Wrapped>::Wrapper(T) [with T = char*, Wrapped = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’:
/.../main.cpp:105: instantiated from here
/.../main.cpp:39: warning: unused variable ‘u’
Linking console executable: bin/Debug/Boost_Serialize_Test
Output size is 252,76 KB
Process terminated with status 0 (0 minutes, 7 seconds)
0 errors, 4 warnings

La partie en rouge montre que le constructeur prend pour string un passage par valeur... or j'aimerais bien avoir, dans ce cas, un passage par référence de type const std::string &...

il faudrait pour cela spécialiser le template, je suppose sur un critère de taille du parametre wrapped. Je me souviens avoir déjà vu ce genre de bout de code sur le forum, mais impossible de le retrouver ... si vous savez ou le trouver ou comment faire , merci d'avance

[bacelar]

Code :

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

Wrapper(T t):Wrapped(t)

Ne serait-ce pas plutôt ça :

Code :

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

Wrapper(const T& t):Wrapped(t)

[Médinoc]

Si tu veux systématiquement un const T&, il suffit de demander.

Sinon, il faut une classe de traits, un truc de ce genre:

Code C++ :

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
template< class T, bool IsBig >
class Param2
{
public:
	typedef T type;
};
 
//Note: je ne me souviens plus de la syntaxe pour les spécialisations partielles de classe template
template< class T >
class Param2< T, true >
{
public:
	typedef T const &type;
};
 
template< class T >
class Param
{
public:
	typedef typename Param2< T, (sizeof(T)>sizeof(long long))>::type type;
};
 
 
template< class T >
void UneFonctionTemplate(typename Param<T>::type toto)
{
	//Blabla
}

[Goten]

ou boost::call_traits<T>::param_type ... .

@Medinoc : c'est bien ça la syntaxe pour la spécialisation partielle.

[méphistopheles]

Sinon, il faut une classe de traits, un truc de ce genre:

c'est effectivement ce qu'il me fallait. la spécialisation est bonne et marche bien.... mais je ne peux pas utiliser le type: je ne comprend pas:

Code :

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

1
2
3
4
5
6
7
8
template< class T >
class Param
{
public:
	typedef typename Param2< T, (sizeof(T)>sizeof(long long))>::type type;
        //error: type ‘Param2<T, (sizeof (T) > 8u)>’ is not derived from type ‘Param<T>’|
        ///error: expected ‘;’ before ‘type’|
};

je vais voir pour boost ....

Edit: quelqu'un pourrai-til tester chez lui pour voir si ça vient de moi ?
merci

[méphistopheles]

je viens de tester avec boost j'ai exactement le même 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
#include <boost/call_traits.hpp>
#include <string>
template <class Wrapped>
class Wrapper : public Wrapped
{
  public:
  Wrapper():Wrapped(){}
 
  template <class T>
  Wrapper( boost::call_traits<T>::param_type  t) //error: expected ‘)’ before ‘t’
    :Wrapped(t)
  {
    char u;
  }
};
 
 
int main()
{
  Wrapper<std::string> * x=new Wrapper<std::string>("blabla");
  return 0;
}

avec comme erreur:

-------------- Build: Debug in Boost_Serialize_Test ---------------

Compiling: main.cpp
/.../main.cpp:41: error: expected ‘)’ before ‘t’
/.../main.cpp: In function ‘int main()’:
/.../main.cpp:101: error: no matching function for call to ‘Wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >::Wrapper(const char [24])’
/.../main.cpp:38: note: candidates are: Wrapper<Wrapped>::Wrapper() [with Wrapped = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]
/.../main.cpp:36: note: Wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >::Wrapper(const Wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)
/.../main.cpp:101: warning: unused variable ‘x’
Process terminated with status 1 (0 minutes, 1 seconds)
2 errors, 1 warnings

(note: les numéros de ligne ne sont pas les bons, car j'ai retiré des commentaires).

quelqu'un a une idée ?

merci

[bacelar]

Truc très con, mais qui m'a souvent dépanné dans le passé, c'est d'utiliser l'option "/P" de VS pour avoir le résultat du pré-processing de l'unité de compilation.
C'est permet de voir des remplacements via MACRO ou des ; manquant en fin de fichier d'include, etc...

Donc quand je comprends rien, je fais cette astuce pour voir si c'est moi ou une connerie dans un fichier d'en-tête connu ni d'Eve ni des dents.

[méphistopheles]

heu...contrairement à visual gcc n'inclut rien de base normalement (a part les librairies iso, mais pas les headers), enfin je vais essayer


Edit: c'est pas les options de compilation : même sur codepad, j'ai ça... personne n'a une idée sur la nature de l'erreur ?

[bacelar]

C'est surtout pour le résultat du traitement des macros par le préprocesseur.

[Jean-Marc.Bourguet]

typename boost::call_traits<T>::param_type ?

[Goten]

faq : typename.


edit : wow grillé de quelques secondes

[zul]

Pourquoi introduit un type T pour ton ctor. Il devrait prendre un type Wrapped en paramètre non ? Il manque un typename associé au boost::call_traits<Wrapped> (voir faq, ou la doc de boost::call_traits).

Ça devrait donner un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template <class Wrapped>
class Wrapper : public Wrapped
{
  public:
  Wrapper():Wrapped(){}
 
  Wrapper(typename boost::call_traits<Wrapped>::param_type  t) 
    :Wrapped(t)
  {
    char u;
  }
};

De toute façon, un type T n'est probablement aps convertible en wrapped et si il l'est le compilateur va faire ça comme un grand.

Side note : c'est vraiment légal de dériver de std::string (destructeur non virtuel, etc ...) ?

edit : grillé deux fois

[méphistopheles]

typename boost::call_traits<T>::param_type ?

>< le pire c'est que c'est pas la première fois que je le rencontre celui-là

Pourquoi introduit un type T pour ton ctor. Il devrait prendre un type Wrapped en paramètre non ?

non car string ne prend pas que des strings en paramètres pour sa construction Il manque un typename associé au boost::call_traits<Wrapped> (voir faq, ou la doc de boost::call_traits).

[...] et si il l'est le compilateur va faire ça comme un grand.

c'est à dire ?


par contre, modifié, le code donne

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
#include <boost/call_traits.hpp>
#include <string>
template <class Wrapped>
class Wrapper : public Wrapped
{
  public:
  Wrapper():Wrapped(){}
 
  template <class T>
  Wrapper(typename  boost::call_traits<T>::param_type  t) //error: expected ‘)’ before ‘t’
    :Wrapped(t)
  {
    char u;
  }
};
 
 
int main()
{
  Wrapper<std::string> * x=new Wrapper<std::string>("blabla");
  return 0;
}

mais là, le compilo est incapable de déterminer un constructeur:

-------------- Build: Debug in Boost_Serialize_Test ---------------

Compiling: main.cpp
/.../main.cpp: In function ‘int main()’:
/.../main.cpp:101: error: no matching function for call to ‘Wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >::Wrapper(const char [24])’
/.../main.cpp:38: note: candidates are: Wrapper<Wrapped>::Wrapper() [with Wrapped = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]
/.../main.cpp:36: note: Wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >::Wrapper(const Wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)
Process terminated with status 1 (0 minutes, 1 seconds)
1 errors, 0 warnings

on a bien evidement l'équivalent sur codepad


Je ne sais pas si c'est dû à cette histoire de types primitifs, mais si c'ets le cas, ça m'embète ...
j'avais construit cette classe par-ce que boost::serialization n'acceptait pas les types primitifs -> retour à la case départ

quelqu'un a une idée ?

[méphistopheles]

vous allez rire (ou pas )

le problème ne vient en fait pas de la classe elle même mais du typename : en effet, si j'écris

Code :

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

1
2
3
4
5
6
7
8
9
template <class Wrapped>
class Wrapper : public Wrapped
{
  public:
  Wrapper():Wrapped(){}
  template <class T>
  Wrapper(T t):Wrapped(t)
  { }
};

ça compile, mais on est confronté au problème initial d'absence de const &...

cependant, en tournant autour du code, j'ai écrit :

Code :

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

1
2
3
4
5
6
7
8
9
template <class Wrapped>
class Wrapper : public Wrapped
{
  public:
  Wrapper():Wrapped(){}
  template <class T>
  Wrapper( typename T t):Wrapped(t)
  { }
};

et là, on retrouve la même erreur que juste au dessus, c'est à dire qu'il ne trouve pas de constructeur approprié: en effet, typename impose que ce soit un type de type class-name mais si on ne l'utilise pas le compilo ne sait pas que c'est un type, mais si on l'utilise, il croit que c'est un class-name mais si on l'utilise pas...

Code :

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

segmentation fault

bref, un peu casse-tête. Le problème revient d'ailleurs à un problème de typage non générique et autre comme dans cette discussion (promis, c'est une coincidence)...

Bon, je vais rebooter et je vous laisse recuser (récursiver ? récursiviter ?) sur ce problème

bonne nuit

[Flob90]

On n'hérite pas de std::string publiquement, pas de destructeur virtuel.

Sinon pour les typename, j'ai pas de compilateur sous la main pour tester (et pas assez d'expérience pour trouver la solution comme ca à ce genre de code). Mais je ne vois pas ce que vient faire là la différence entre classe-name et type (et encore moins le rapport entre ce problème et ta volonté d'hériter d'autre chose que d'une classe !).

Un classe-name c'est juste ce qui représente le nom d'une classe, un type caractérise la facon dont les données doivent être traitées (pas de meilleur définition sur le coup :s). Et typename et juste une indication au compilateur qui lui signifie que ce qui suit est bel et bien un type (il ne peut en être sûre à cause du paramètre template), donc dans ton avant dernier code le typename sert à rien, le compilateur sait que T est un type.

[Nogane]

j'avais construit cette classe par-ce que boost::serialization n'acceptait pas les types primitifs

Bonsoir,
Je ne vois pas bien ce que vous voulez dire. En quoi boost::serialization n'accepte-t-il pas les type primitifs?

[méphistopheles]

On n'hérite pas de std::string publiquement, pas de destructeur virtuel.

pas vraiment un problème dans mon cas puique je n'ai pas d'autre objets à détruire...

Un classe-name c'est juste ce qui représente le nom d'une classe, un type caractérise la facon dont les données doivent être traitées (pas de meilleur définition sur le coup :s). Et typename et juste une indication au compilateur qui lui signifie que ce qui suit est bel et bien un type (il ne peut en être sûre à cause du paramètre template), donc dans ton avant dernier code le typename sert à rien, le compilateur sait que T est un type.

je veux bien te croire, je ne fais que constater... d'aprés l'exemple ci-dessus, ils semble que le typename aie un effet réel alors qu'il ne dervrait juste "servir à rien" ... ce qui est relativement curieux.
Pour le compilateur, il y a toujours codepad .

Bonsoir,
Je ne vois pas bien ce que vous voulez dire. En quoi boost::serialization n'accepte-t-il pas les type primitifs?

je l'explique dans ce sujet . c'est un tout petit point de la grosse doc de serialization.

[zul]

As-tu essayé la variante que j'ai proposé ?
Comme je le disais, le type T accepté par le template sont les types directement convertibles vers Wrapped. Mais si ils sont directement convertibles par Wrapped, le compilateur va appliquer la conversion automatiquement (voir chapitre 4 de la norme sur les standards + les constructeurs non explicites).

Même si tu n'a pas d'autres champs, ça reste il me semble un UB.

Sinon, pourquoi veux tu absolument utiliser des pointeurs nus vers std::string ? Quel est l'intérêt ?

[méphistopheles]

As-tu essayé la variante que j'ai proposé ?
Comme je le disais, le type T accepté par le template sont les types directement convertibles vers Wrapped. Mais si ils sont directement convertibles par Wrapped, le compilateur va appliquer la conversion automatiquement (voir chapitre 4 de la norme sur les standards + les constructeurs non explicites).

à vrai dire je n'ai pas bien compris de quoi il s'agissait (si c'est une optimisation post résolution des templates ou pré résolution des templates) etc... si celle-ci se fait avant, le premier post du sujet prouve que ça ne marche pas puisque le type de l'argument est un std::string et non un const std::string &...

Compiling: main.cpp
/.../main.cpp: In constructor ‘Wrapper<Wrapped>::Wrapper(T) [with T = std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Wrapped = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]’:[...] warning: unused variable ‘u’

Même si tu n'a pas d'autres champs, ça reste il me semble un UB.

UB ?

Sinon, pourquoi veux tu absolument utiliser des pointeurs nus vers std::string ? Quel est l'intérêt ?

ben à la base je voulais utiliser des pointeurs sur n'importequoi. or ça marchait pas avec des string. j'ai donc voulu faire un wrapper généric pour résoudre le problème des pointeurs... c'aurait été facile si je l'avais fait juste pour les string (y'a pas 50000 constructeurs à surcharger) mais comme je suis un entété, je veux pas m'abaisser à faire du cas par cas (alors que je ne travaille que sur un cas, je sais, très logique, mais bon, il faut bien résoudre un problème avant d'attaquer les autres ).

[zul]

Si tu ne veux pas essayer / tester / comprendre, on ne peut rien faire pour toi.
En l'occurence, ton constructeur attend ici un const std::string&, et le compilateur va essayer de trouver une conversion entre un const char[] et un const std::string& (ça tombe bien y'en a un).

UB = Undefined Behaviour (Comportement Indéfini)

Et c'est définitivement une mauvaise raison