Discussion :

[NoIdea]

Bonjour, j'aimerais faire un vecteur trié. cependant, j'obtiens quelques problèmes au niveau de la spécialisation des templates pour les pointeurs.

Voici ce que j'ai fait jusqu'à présent et qui ne gère pas cette aspect :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<typename Object, typename Sort,class Storing=std::list<std::pair<Object*,Sort>>>
class Sorted
{
    private :
        Storing List;
    public :
        Sorted()=default/*J'utilise c++0x*/;
        Sorted(const Sorted&)=delete;
        Sorted& operator=(Sorted&)=delete;
        ~Sorted()=default;
        void AddElement(Object* Element, Sort Position);
        inline void EraseElement(Object* Element);
        inline void ForEach(void (Object::*Function)(void));
};

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
template<typename Object, typename Sort, class Storing>
inline void Sorted<Object, Sort, Storing>::AddElement(Object* Element, Sort Position)
{
    typename Storing::iterator it;
    for(it=List.begin();it!=List.end();it++)
        if(it->second<=Position)
            break;
    List.insert(it,std::make_pair(Element,Position));
}
 
template<typename Object, typename Sort, class Storing>
void Sorted<Object, Sort, Storing>::EraseElement(Object* Element)
{
    for(auto/*J'utilise c++0x*/ it=List.begin();it!=List.end();it++)
    {
        if(it->first==Element)
        {
            List.erase(it);
            return ;
        }
    }
}
 
template<typename Object, typename Sort, class Storing>
inline void Sorted<Object, Sort, Storing>::ForEach(void (Object::*Function)(void))
{
    for(auto it=List.begin();it!=List.end();it++)
        (it->first->*Function)();
}

Mon problème :

-Cette classe ne marche pour l'instant que si Object est un pointeur et si sort n'est pas un pointeur. Comment adapté pour que sa marche dans tous les cas ?
-D'autres problèmes ? (Peut être on peut faire un Storing = std::list sans spécifier les template de la liste ? ce qui permettrais, si on veut un vector de juste passer un std::vector et non std::vector<std::pair<...>>)

J'espère que le code est assez explicite pour comprendre ce que la classe fait (c'est un conteneur trié).

Merci de votre aide.

[Joel F]

Au lieu d'untilsier un pointeur de fonction, utilise un parametere tempalte non spécifié, ca te permetrra deja de pas te hardcoder sur les types de la fonctions.

Ensuite, pourquoi passe tu un pointeur sur objet ?

[NoIdea]

Au lieu d'untilsier un pointeur de fonction, utilise un parametere tempalte non spécifié, ca te permetrra deja de pas te hardcoder sur les types de la fonctions.

Pas de problème la dessus, je vais le changer.

Ensuite, pourquoi passe tu un pointeur sur objet ?

Parce que dans l'utilisation principale que j'en fait, c'est un pointeur de fonction virtuelle que j'utilise.


La classe telle quelle est me suffit très largement pour l'utilisation minimale que j'en fait. Ce que j'aimerais faire, c'est la rendre utile pour d'autres projets (être le plus générique possible).

[NoIdea]

Pas de problème la dessus, je vais le changer.

En fait, je rencontre un petit problème :

Si je fais un template<typename Fc>, il faudrait spécialiser si c'est une fonction membre ou pas : si Fc est une Fonction membre, j'appelle la fonction comme en haut, sinon j'appelle la fonction comme sa Function(*(it->first));

Comment gérer cette différence de syntaxe ? Un boost ou std::bind ? Un lambda ?

[Joel F]

bind avec le *this ou bien utilisez un traits pour detecter si Fc est un member_function_pointer et spécialiser selon.

[NoIdea]

bind avec le *this ou bien utilisez un traits pour detecter si Fc est un member_function_pointer et spécialiser selon.

Ok, c'est ce que je pensais.

Me reste toujours un gros problème : comment spécialiser dans le cas ou object est un pointeur et si possible de ne pas avoir à spécifier les template de Storing. Il me faudrait juste la syntaxe pour écrire la classe : google ne semble pas vouloir lâcher les réponses...

[NoIdea]

bind avec le *this ou bien utilisez un traits pour detecter si Fc est un member_function_pointer et spécialiser selon.

Je viens de régler le problème ainsi :

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 Fc, typename Obj, typename R, typename ...Args>
struct CallFunction
{
    inline static R Call(Fc Function, Obj& Object, Args...Arguments)
    {
        return Function(Object, Arguments...);
    }
 
};
 
template<typename Obj, typename R, typename ...Args>
struct CallFunction<R(Obj::*)(Args...),Obj,R,Args...>
{
    inline static R Call(R(Obj::*Function)(Args...), Obj& Object, Args...Arguments)
    {
        return (Object.*Function)(Arguments...);
    }
};

Cependant, mes 2 autres problèmes persistent (au passage semblerait que gcc considère que
void (truc::*)(void) n'est pas du même type que
void(truc::*)()

[NoIdea]

Tous mes problèmes sont quasiment réglés, cependant, reste un dernier problème : Si l'utilisateur veut utilisé un conteneur n'utilisant pas de allocator( donc pas de la STL), comment faire ?

Voici le code du header :

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
template<typename Object, typename Sort,template<typename, typename>class Storing=std::list>
class Sorted
{
    private :
        Storing<std::pair<Object, Sort>, std::allocator<std::pair<Object, Sort>>> List;
    public :
        Sorted()=default;
        Sorted(const Sorted&)=delete;
        Sorted& operator=(Sorted&)=delete;
        ~Sorted()=default;
        void AddElement(Object Element, Sort Position);
        inline void EraseElement(Object Element);
        template<typename Fc>
        inline void ForEach(Fc Function);
};
 
template<typename Object, typename Sort,template<typename, typename>class Storing>
class Sorted<Object*, Sort, Storing>
{
    private :
        Storing<std::pair<Object*, Sort>, std::allocator<std::pair<Object*, Sort>>> List;
    public :
        Sorted()=default;
        Sorted(const Sorted&)=delete;
        Sorted& operator=(Sorted&)=delete;
        ~Sorted()=default;
        void AddElement(Object* Element, Sort Position);
        inline void EraseElement(Object* Element);
        template<typename Fc>
        inline void ForEach(Fc Function);
};

Comment faire pour utiliser les template par défaut de la STL ?
Pour ne pas avoir à préciser template<typename,typename> class Storing : Si il n'y a qu'un paramètre template ?

[Joel F]

Ne passe pas de paramètres template template mais un simple parametre template et utilise des traits ou des concepts pour valider la correction de ton appel.

[NoIdea]

Ne passe pas de paramètres template template mais un simple parametre template

Je perds alors en simplicité : l'utilisateur doit faire std::vector<std::pair<...,...>> alors que dans le cas actuel, l'utilisateur n'est même pas au courant de l'utilisation de std::pair.

Je viens d'y penser, 2 autres spécialisations ne régleraient-elles pas le problème ?

[Steph_ng8]

Bonjour, j'aimerais faire un vecteur trié.

Un multiset ne correspondrait pas à tes attentes ?

Steph.

[NoIdea]

Un multiset est un peu trop lourd pour le peu que j'en fait. De plus, il ne présente pas l'avantage du ForEach (implémentable si agrégation).
Je prévois d'étendre cette classe mais uniquement dans les méthodes et en les gardant très basique (je prévois une option d'accéder aux éléments) et etc...

[Steph_ng8]

D'accord.

[Joel F]

Je perds alors en simplicité : l'utilisateur doit faire std::vector<std::pair<...,...>> alors que dans le cas actuel, l'utilisateur n'est même pas au courant de l'utilisation de std::pair.

Je viens d'y penser, 2 autres spécialisations ne régleraient-elles pas le problème ?

Perso je passerais un constructeur meta-lambda, et ton Storing aurait comme parametere supplementaire le type de pair à utiliser.

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
 
template<class Container, class Pair = std::pair<mpl::_1,mpl::_2>
struct Storing
{
private :
  typedef typename mpl::apply2<Pair,Object,Sort>::type pair_type;
  typedef typename mpl::apply1<Container, pair_type>::type data_type;
 
  data_type List;
 
 // etc ...
};
 
typedef Storing< std::vector<mpl::_> > store_vector;
typedef Storing< std::list<mpl::_>, tuple<mpl::_1,mpl::_2> > store_list_with_tuple;

En interne, passe par les at_c de boost::fusion et tu gère tout les cas sans passer par un type concret. Ca rend ton design indépendant du type de pair (on peut y mettre un tuple ou tt autre séquence fusion) et ca régle ton probleme de parametrage.