Template et Pointeur sur Predicat

Version imprimable

bonjour,

Dans un template j'aurai voulu définir un pointeur sur un "predicat binaire", j'ai vu qu'il existait un pointer_to_bniary_function dans la STL mais je n'ai pas su trouver comment l'utiliser.

Extrait du template :
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 template <typename T> class IRow { public: // etc... template<class _Predicate> typename std::list<T>::const_iterator find(_Predicate); template<class _BinaryPredicate> void sort(_BinaryPredicate) { __M_sort_pred = __binary_pred; __M_value_list.sort(__binary_pred); } protected: void _merge(std::list<T> &__list) { __M_value_list.merge(__list, __M_sort_pred ); } _BinaryPredicate __M_sort_pred; std::list<T> __M_value_list; };
Mais est-il possible de definir ce type de pointeur dans un template ? Et peut-on l'implémenter par un "pointer_to_binary_function" ?

29/09/2007, 23h27
koala01

Salut,

Juste une petite remarque au sujet de l'utilisation des underscore...

Les noms (de variables et ou de fonctions) contenant un underscore ou commençant par deux underscore ( __ ) sont normalement réservés pour l'implémentation des compilateurs et de la bibliothèque standard, de manière à éviter les éventuels conflits ;)

A moins que tu ne tentes d'implémenter ta propre version de la bibliothèque standard ou de compilateur, il est donc de bon ton que d'éviter de préfixer tes noms de variables de la sorte ;)

Citation:
Envoyé par sas
bonjour,

Dans un template j'aurai voulu définir un pointeur sur un "predicat binaire", j'ai vu qu'il existait un pointer_to_bniary_function dans la STL mais je n'ai pas su trouver comment l'utiliser.

Extrait du template :
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 template <typename T> class IRow { public: // etc... template<class _Predicate> typename std::list<T>::const_iterator find(_Predicate); template<class _BinaryPredicate> void sort(_BinaryPredicate) { __M_sort_pred = __binary_pred; __M_value_list.sort(__binary_pred); } protected: void _merge(std::list<T> &__list) { __M_value_list.merge(__list, __M_sort_pred ); } _BinaryPredicate __M_sort_pred; std::list<T> __M_value_list; };
Mais est-il possible de definir ce type de pointeur dans un template ? Et peut-on l'implémenter par un "pointer_to_binary_function" ?
regarde http://www.sgi.com/tech/stl/ptr_fun.html
Il permet de transformer un pointeur sur une fonction Binaire/unaire en pointeur que tu veut.

30/09/2007, 15h20
sas
Merci Mongaulois, j'ai donc essayé de mettre en place cette solution mais je n'arrive même pas à déclarer le pointeur, si je met :
Code:

1 2 3 template <class Arg1, class Arg2, class Result> Result (*__M_sort_pred)(Arg1, Arg2);
j'ai une erreur du type : data member `__M_sort_pred' cannot be a member template
30/09/2007, 15h50
yan
Citation:
Envoyé par sas

Merci Mongaulois, j'ai donc essayé de mettre en place cette solution mais je n'arrive même pas à déclarer le pointeur, si je met :

Code:

1 2 3 template <class Arg1, class Arg2, class Result> Result (*__M_sort_pred)(Arg1, Arg2);

j'ai une erreur du type : data member `__M_sort_pred' cannot be a member template
`__M_sort_pred' c'est quoi??

ptr_fun te donne :
template <class Arg1, class Arg2, class Result>
pointer_to_binary_function<Arg1, Arg2, Result>
30/09/2007, 16h55
sas

'__M_sort_pred' est censé être la donnée membre du template qui contient ce pointeur. Mais je n'arrive pas à la déclarer, et je ne sais pas si c'est possible.
30/09/2007, 17h54
yan

Citation:

Envoyé par sas

'__M_sort_pred' est censé être la donnée membre du template qui contient ce pointeur. Mais je n'arrive pas à la déclarer, et je ne sais pas si c'est possible.

faut connaite Arg1,Arg2 et Result
pointer_to_binary_function<Arg1, Arg2, Result> * __M_sort_pred;

Par contre si tu peut, evite le nom avec de _ ou __ devant. Normalment c'est une notation réservé au compilot. Perso j'aime bien m_
08/10/2007, 11h48
poukill

C'est aussi la notation que j'utilise.

Après avoir étudié le problème, il m'était impossible de coder cette fonctionnalité:

J'aurais voulu 'enregistrer' dans un pointeur un foncteur de tri pour une 'std::list' d'un template afin de pouvoir le rappeler quand j'ai besoin de faire un 'merge' sur cette 'std::list' lors d'ajout/modification d'éléments.

Voici un exemple de code :

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
class Object
{
public:
	Object() : m_i(0) {}
	virtual ~Object() {}
 
	int get_value() const { return m_i; }
	void set_value(int ivalue) { m_i = ivalue; }
private:
 
	int m_i;
};
 
struct triObjectFunctor {
	bool operator() (const Object &lhs, const Object &rhs) const {
		return ( lhs.get_value() < rhs.get_value() );
	}
};
 
// ajout de 
inline bool triObjectFunction(const Object &lhs, const Object &rhs)
{
    return triObjectFunctor()(lhs, rhs);
}
 
template <typename T>
class IRow 
{
public: 
 
	IRow() : m_sort_pred(NULL) {}
	virtual ~IRow() {}
 
	// etc...
 
        // ancienne déclaration
        // void sort( std::pointer_to_binary_function<T, T, bool> * p_)
        // remplacée par :
	void sort( bool (*binary_pred_)(const T&, const T&) )
	{
		m_sort_pred = binary_pred_;
 
		m_list.sort(*binary_pred_);		
	}
 
private:
 
	void merge(std::list<T> other_list)
	{
		if (m_sort_pred != NULL )
		{
			m_list.merge( other_list, *m_sort_pred );
		}
                else
                {
                        m_list.merge( other_list );
                }
	}
 
	std::list<T> m_list;
 
        // code érroné
        // std::pointer_to_binary_function<T, T, bool> * m_sort_pred;
        // rempacé par
        bool (*m_sort_pred)(const T&, const T&);
};
 
class ORow : public IRow<Object>
{
public:
 
	ORow() : IRow<Object>::IRow() {}
}
 
// appel de sort
{
    ORow row;
 
    row.sort( triObjectFunction );
}

EDIT : En lisant les derniers posts de ce forum, j'ai finallement trouver une solution.