C++

Spécialisation d'un modèle vers modèle utilisant des pointeurs

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Spécialisation d'un modèle vers modèle utilisant des pointeurs

Amonchakai

Bonjour,
Je me suis posé un petit exercice : j'ai d'abord cherché à créer un modèle de conteneur associatif.
Ce qui me donne :

Code :

#include<vector>
#include<algorithm>
template<typename T, typename T2>
struct Pair
{
T key;
T2 value;
Pair(T gkey):key(gkey){};
Pair(T gkey, T2 gvalue):key(gkey), value(gvalue) {};
bool operator==(const Pair<T, T2> &other);
};
template<typename T, typename T2>
bool Pair<T, T2>::operator ==(const Pair<T,T2> &other)
{
return (other.key == key);
}
template<typename T, typename T2>
class Map
{
std::vector<Pair<T, T2>> data;
public:
typedef typename std::vector<Pair<T,T2>>::iterator iterator;
iterator begin();
iterator end();
virtual T2 &operator[](T key);
};
template<typename T, typename T2>
T2 &Map<T, T2>::operator [](T key)
{
std::vector<Pair<T, T2>>::iterator it = data.begin();
it = std::find(data.begin(), data.end(), Pair<T,T2>(key, T2()));
if(it == data.end())
{
data.push_back(Pair<T,T2>(key, T2()));
return (data.back()).value;
}
else
return (*it).value;
}
template<typename T, typename T2>
typename Map<T,T2>::iterator Map<T, T2>::begin()
{
return data.begin();
}
template<typename T, typename T2>
typename Map<T,T2>::iterator Map<T, T2>::end()
{
return data.end();
}

Donc ça, j'ai pas de soucis : ça marche. Mais a titre d'exercice je me suis dit que j'allais chercher a traiter autrement les pointeurs. Donc pour cela j'ai dérivé mon modèle comme ça :

Code :

template<typename T, typename T2>
class Map<T, T2*> : public Map<T, T2>
{
public:
T2 *operator[](T key);
};
template<typename T, typename T2>
T2 *Map<T, T2*>::operator [](T key)
{
std::vector<Pair<T, T2>>::iterator it = data.begin();
it = std::find(data.begin(), data.end(), Pair<T,T2>(key));
if(it == data.end())
{
data.push_back(Pair<T,T2*>(key, &T2()));
return (data.back()).value;
}
else
return (*it).value;
}

Mais la, mon problème c'est qu'il est pas content que le type de retour de mon opérateur [] change entre la classe mère et la classe fille. Ce que je comprend... mais en fait je vois pas comment régler le problème. (autre que de changer d'exemple pour m'entrainer à ce type de spécialisation... )

Donc, je sais pas si vous voyez une solution...
Merci

ps : au passage si il y a quelque chose qui vous choque dans mon utilisation des modèles, merci de me le signaler (je demande qu'a m'améliorer )

Publicité

Joel F

Real men use unique_ptr

Bon ... y a des trucs à revoir :|

Deja ton schéma d'héritage entre modèle me
parait pas la meilleur solution. Ensuite, tu
cherche à spécialiser partiellement une méthode
de ton modèle dans le cas ou T2 est un pointeur.
Pour cela, il te faut résoudre 2 problèmes :

-> générer un type de retour valide
-> changer le contenu de ta méthode.

Une maniére plus propre consiste à :

1/ Génération du type de retour :
On utilise une technique qui s'appelle les Traits.
Cette technique consiste à utiliser des spécialisations
de template comme un filtre logique (un match en ML).
Ici on a deux cas :

T2 quelconque -> on renvoit T2&
T2* -> on renvoit T2*

En outre, lorsque tu crée T2& , il faut faire gaffe au fait
que T2 ne soit pas déjà une référence ! On crée donc le modèle
suivant

Code :

template<class T> struct return_type
{
typedef T& type;
};
template<class T> struct return_type<T&>
{
typedef T& type;
};
template<class T> struct return_type<T*>
{
typedef T* type;
};

On peut désormais récupérer le type de retour de manière géénrique.

2/ Modifier le contenu de ta méthode
Même constat. On va exporter le code dabs un modèle ad-hoc qui sera appelé depuis ton modèle.

On crée donc un modèle qui ne contient que ton code de recherche dnas chaque cas.

Code :

template<class T, class T2>
struct map_access
{
typedef typename return_type<T2>::type type;
typedef std::vector<Pair<T,T2>> map_type;
static inline type run( const T& key, const map_type& data )
{
typename map_type::iterator it = data.begin();
it = std::find(data.begin(), data.end(), Pair<T,T2>(key, T2()));
if(it == data.end())
{
data.push_back(Pair<T,T2>(key, T2()));
return (data.back()).value;
}
else
return (*it).value;
}
};
template<class T, class T2>
struct map_access<T,T2*>
{
typedef typename return_type<T2*>::type type;
typedef std::vector<Pair<T,T2*>> map_type;
static inline type run( const T& key, const map_type& data )
{
typename map_type::iterator it = data.begin();
it = std::find(data.begin(), data.end(), Pair<T,T2*>(key));
if(it == data.end())
{
data.push_back(Pair<T,T2*>(key, &T2()));
return (data.back()).value;
}
else
return (*it).value;
}
};

Au final le code de Map<T,T2>::operator[] devient

Code :

template<typename T, typename T2>
typename return_type<T2>::type Map<T, T2>::operator [](T key)
{
return map_access<T,T2>::run(key,data);
}

Voila le principe.

Ensuite quelques conseils :

1/ std::map pue du bec que tu ai envie d'en réécrire un moins bien ?
2/ Y a plein de problème de const qui manque partout ...
3/ Il faut garder à l"esprit que lorsque tu écris du code à base de template, il faut que la PLUS GROSSE PARTIE du code manipulant des types soit générique. T2& c'ets pas générique, return_type l'est beaucoup plus car tu contrôle précisement tes schémas de spécialisation.
4/ utilise le plus possible les modéles de BOOST::Traits et de BOOST::mpl pour te simplifier la vie sur ce genre de tests

Message édité par Joel F le 16-03-2007 à 09:00:10

Amonchakai

Merci, beaucoup de ton aide !

Bon, je vais m'entrainer encore mais j'ai compris le principe
bien sur, il est clair que c'est pas que la std::map "pue du bec" que j'ai essayé d'en faire une mais en fait c'est un exercice qui étais proposé dans mon Stroustrup. Je viens de lire le chapitre sur les modèles et donc je fais ensuite les exercices

Donc je vais améliorer tout ça... Merci pour tes conseils et de m'avoir montré le principe qu'il faut utiliser

Taz

bisounours-codeur

ouaich, vive les traits (que y en a plein de défini en standard déjà)

Message cité 1 fois

++fab

victime du syndrome IH

Taz a écrit :

ouaich, vive les traits (que y en a plein de défini en standard déjà)

mmouuais. C'est dans TR1, et ce sera probablement au prochain standard, mais c'est surclassé par les concepts.

FORUM HardWare.fr

Programmation

C++

Spécialisation d'un modèle vers modèle utilisant des pointeurs

Sujets relatifs
linux: compiler en utilisant allegro	Avis pour programme utilisant JAI (Java Advanced Imaging)
création automatique de raccourcis vers des dossiers	nom-domaine.fr: redirection nom de domaine vers site
HELP! Parser un fichier de conf et renvoyer vers struct	Page hmtl vers Message Outlook
[POO] Champ de texte et MVC (modèle vue contrôleur)	[PHP] Comment on limite les accès à un forum via chmod ?
Un ControlToValidate (composant .net) qui pointe vers une fonction	Variable d'un applet java vers du php
Plus de sujets relatifs à : Spécialisation d'un modèle vers modèle utilisant des pointeurs

Page générée en 0.072 secondes