Pointeur sur les fonctions membres – C ++ std :: list

Comment puis-je passer un pointeur sur une fonction membre à std :: list.sort ()?

Est-ce possible? Merci

struct Node { uint32_t ID; char * Value; }; class myClass { private: uint32_t myValueLength; public: list MyQueue; bool compare(Node * first, Node * second); bool doStuff(); } bool myClass::compare(Node * first, Node * second) { unsigned int ii =0; while (ii  Value[ii]  Value[ii]) { return true; } else if (first-> Value[ii] > second-> Value[ii]) { return false; } ++ii; } return false; } bool myClass::doStuff() { list.sort(compare); }

Je veux utiliser une variable de longueur dans la classe au lieu de strlen () dans la fonction de comparaison (la valeur aura toujours la même longueur)

Edit: myValueLength n’était pas la seule variable à laquelle je voulais accéder depuis la fonction de comparaison, je l’ai simplement simplifiée pour rendre l’exemple plus court.

En développant la réponse de grieve , pourquoi ne pas utiliser un foncteur? Par exemple:

 struct Functor { bool operator()( char * a, char * b ) { return strcmp(a,b) < 0; } };

Ensuite, vous pouvez simplement utiliser:

 Functor f; myList.sort(f);

Vous pouvez même utiliser votre classe en tant que Functor en définissant operator () ...

 class myClass { ... bool operator()( queueNode * a, queueNode * b ) { return compare( a, b ); } void doStuff() { MyQueue.sort(*this); } };

Exemple de code simple:

 #include  #include  using namespace std; // Assumes TYPE t; cout << t; is valid. template inline ostream & operator<< ( ostream & theOstream, const list & theList ) { typename list::const_iterator listIterator = theList.begin(); for ( int i = 0; listIterator != theList.end(); listIterator ++, i ++ ) theOstream << " [" << i << "]: \"" << (*listIterator) << "\"" << endl; return theOstream; } struct Functor { bool operator()( const char * a, const char * b ) { return strcmp(a,b) < 0; } }; int main() { list l; /* Load up some example test data... */ char s[3]; s[2] = '\0'; for ( s[0]='c'; s[0]>='a'; s[0]-- ) for ( s[1]='c'; s[1]>='a'; s[1]-- ) l.push_back(strdup(s)); /* Show us that test data... */ cout << l << endl; /* Sort list. */ Functor f; l.sort(f); /* Show us what we have now... */ cout << l << endl; }

C’est possible. Avez-vous envisagé d’utiliser boost :: function?

 list.sort( boost::bind( &myClass::compare, this, _1, _2 ) );

Est-ce que votre fonction ‘comparer’ s’appuiera sur ces données? Sinon, vous pouvez simplement faire en sorte que la fonction ‘compare’ soit statique . Et puis ce sera

 list.sort( &myClass::compare );

Vous pouvez append une structure d’aide pour faire votre comparaison, puis

 list.sort( Comparer( myValueLength ) ); struct Comparer { Comparer( uint32_t myValueLength ): length( myValueLength ) {} bool operator() (Node * first, Node * second) { unsigned int ii =0; while (ii < length) { if (first-> Value[ii] < second-> Value[ii]) { return true; } else if (first-> Value[ii] > second-> Value[ii]) { return false; } ++ii; } return false; } uint32_t length; };

Vous voudrez peut-être utiliser un foncteur.

http://www.newty.de/fpt/functor.html

Notez que std::list sortinge l’élément en fonction de l’ operator< défini pour cet élément. Vous devez modifier votre fonction de compare pour utiliser un operator< global operator< défini pour les objects Node :

 bool operator<(Node const& first, Node const& second) { unsigned int ii =0; while (ii < length) { if (first.Value[ii] < second.Value[ii]) { return true; } else if (first.Value[ii] > second.Value[ii]) { return false; } ++ii; } return false;

}

Une amélioration suggérée sera:

 bool operator<(Node const& first, Node const& second) { for (size_t ii =0; first.Value[ii] == second.Value[ii]; ++ii) ; // note ; return (first.Value[ii] < second.Value[ii]); }

Si char *Value représente vraiment une chaîne de style C et que vous souhaitez un sorting lexicographique, d'autres améliorations sont possibles:

 bool operator<(Node const& first, Node const& second) { return (strcmp(first.Value, second.Value) < 0); }

et si ce sont vraiment des chaînes, je vous suggère d'utiliser std::ssortingng et vous pouvez écrire:

 bool operator<(Node const& first, Node const& second) { return first.Value < second.Value; }

Comme le chagrin & mrree suggéré

simplement surcharger l’opérateur () fonctionne

Merci à tous ceux qui ont répondu

 struct Node { uint32_t ID; char * Value; }; class myClass { private: uint32_t myValueLength; public: list MyQueue; bool operator()(Node * first, Node * second); bool doStuff(); } bool myClass::operator()(Node * first, Node * second) { unsigned int ii =0; while (ii < myValueLength) { if (first-> Value[ii] < second-> Value[ii]) { return true; } else if (first-> Value[ii] > second-> Value[ii]) { return false; } ++ii; } return false; } bool myClass::doStuff() { list.sort(*this); }

Pourquoi ne pas rendre votre fonction de comparaison statique, vous n’avez plus besoin du foncteur. Ensuite, vous pouvez simplement faire list.sort (comparer);

ça ne fait rien … Je viens de me rendre compte que votre fonction de comparaison utilise un membre de données de classe, elle ne peut donc pas être statique. Utilisez Functor 🙂