C++ std de tri de la liste personnalisée comparateur de qui dépend d'une variable de membre de l'instance de l'objet

Classe:

Class:
  private:
    ...
    vector<string> words; 
    vector< list<int> > vints;
  public:
    myFunction(...)

Que j'appelle une sorte de non-vide de la liste dans une autre fonction membre:

void myClass::myFunction (...) {
    ...
    if (!vints[i].empty()) vints[i].sort(sortFunc);
    ...
}

Ma fonction de tri:

bool myClass::sortFunc(const int& i, const int& j) { return (words[i] < words[j]); }

L'Erreur:

error: no matching function for call to ‘std::list<int, std::allocator<int>      >::sort(<unresolved overloaded function type>)’
/usr/include/c++/4.4/bits/list.tcc:301: note: candidates are: void std::list<_Tp,     _Alloc>::sort() [with _Tp = int, _Alloc = std::allocator<int>]
/usr/include/c++/4.4/bits/list.tcc:378: note:                 void std::list<_Tp, _    Alloc>::sort(_StrictWeakOrdering) [with _StrictWeakOrdering = bool (SuperWordSearch::*)    (const int&, const int&), _Tp = int, _Alloc = std::allocator<int>]

J'ai fait des recherches et tombe sur les questions suivantes:

C++ Personnalisé fonction de comparaison pour la liste::sort

Problème de tri d'une liste de pointeurs

Erreur dans std::list::tri personnalisé comparateur (expected primary-expression before ')' token)

et ils auraient été suffisant s'il n'avait pas été le fait que dans cette classe, le sortFunc dépend de la variable de membre de MOTS pour cette instance de l'objet. Je ne peux donc pas faire le comparateur de fonction (sortFunc) globales ou statiques

EDIT: Viens de tomber sur ce Comment trier un std:liste lorsque vous avez besoin des données sur les membres? et il fournit une solution en faisant un ami de classe, mais est-il possible de réaliser cela à l'intérieur de la classe définie par l'utilisateur lui-même?

Merci de ne pas utiliser toutes les lettres majuscules identificateurs (sauf pour les macros, où vous devez les utiliser).
Fixe. A essayer de faire de l'info pertinente de se démarquer.
Est-ce C++11? Pouvez-vous utiliser les lambdas ou bind()?
¤ L'idée de base est de passer d'un objet qui a une operator() de sorte qu'il peut être utilisé en tant que fonction. Cela s'appelle une foncteur. En C++11, vous pouvez créer une telle bête à la volée, comme un "lambda". En C++98/03 vous devez définir une classe, ou d'utiliser certains tiers bibliothèque comme Boost. E. g. vous pouvez utiliser boost::bind à avoir un pointeur de votre words, transmise à votre réel de la fonction. Cheers & hth.,

OriginalL'auteur encore2097 | 2011-12-04

  1. 2

    @Kerrek réponse impliquant des lambdas, c'est mieux. Mais, si vous devez éviter de C++11 caractéristiques, puis remplacez votre fonction de tri avec un foncteur. Permettre que le foncteur de stocker une référence à toutes les données nécessaires, comme:

    #include <vector>
#include <list>
#include <string>

class myClass {
private:
  std::vector<std::string> words;
  std::vector<std::list<int> > vints;

  //Instead of sortFunc, use sortFunctor. A functor can be used in place 
  //of a function in many places, and it can carry state (like a reference
  //to the data it needs).
  struct sortFunctor {
    const std::vector<std::string>& words;
    sortFunctor(const std::vector<std::string>& words) : words(words) { }
    bool operator()(int i, int j) { return words[i] < words[j]; }
  };

public:
  void myFunction() {
    vints[0].sort(sortFunctor(words));
  }
  myClass() {
    words.push_back("apple");
    words.push_back("berry");
    std::list<int> l;
    l.push_back(0);
    l.push_back(1);
    vints.push_back(l);
  }
};

int main () {
  myClass object;
  object.myFunction();
}
    Ne pouvez pas battre le classiness de lambdas, mais qui nécessite un C++11 qui, actuellement, je ne peut pas utiliser.

    OriginalL'auteur Robᵩ

  2. 9

    Avec les lambdas:

    vints[i].sort([&words](int i, int j) { return words[i] < words[j]; });

    Avec std::bind:

    #include <functional>

//...
{
  using namespace std::placeholders;
  vints[i].sort(std::bind(&myClass::sortFunc, this, _1, _2));
}
    Est-il impossible à résoudre sans C++11 caractéristiques?
    Vous devez préciser le prédicat vous-même. Chaque lambda peut trivialement être étendu en un foncteur, c'est juste bruyant. Avez-vous besoin d'aide?
    Hrm... j'obtiens les erreurs suivantes en essayant la méthode bind (Ubuntu linux x64, g++ v. 4.4.3:) error: ‘placeholders’ is not a namespace-name error: expected namespace-name before ‘;’ token error: ‘bind’ is not a member of ‘std’ error: ‘_1’ was not declared in this scope error: ‘_2’ was not declared in this scope
    SB: Merci, j'ai oublié de spécifier la std. @ Rob: je ne sais pas à quoi vous faites allusion.

    OriginalL'auteur Kerrek SB

  3. 0

    === Mise à JOUR ===

    Voici une solution de contournement sans l'aide de C++11 caractéristiques:

    #include <exception>
#include <iostream>
#include <list>
#include <string>
#include <vector>
using namespace std;
class MyClass
{
private:
vector<string*> words;
vector< list<string*> > vptrs;
static bool sortFunc(const string* s1, const string* s2)
{
return (*s1 < *s2);
}
public:
MyClass()
{
vptrs.push_back(list<string*>());
}
~MyClass()
{
for (int i = 0; i < vptrs.size(); ++i)
vptrs[i].clear();
for (int i = 0; i < words.size(); ++i)
delete words[i];
}
void addWord(const char* s)
{
words.push_back(new string(s));
}
void setWord(int i, const char* s)
{
*words[i] = s;
}
void addIndex(int i, int j)
{
vptrs[i].push_back(words.at(j));
}
void sort(int i)
{
if (!vptrs[i].empty())
vptrs[i].sort(sortFunc);
}
void print(int i)
{
list<string*>::iterator s;
for (s = vptrs[i].begin(); s != vptrs[i].end(); ++s)
cout << **s << endl;
}
};
int main(int argc, char **argv)
{
try
{
MyClass* c = new MyClass();
c->addWord("apple");
c->addWord("hello");
c->addWord("world");
c->addIndex(0, 1);
c->addIndex(0, 2);
c->addIndex(0, 0);
c->setWord(2, "pear");
cout << "Before sort:" << endl;
c->print(0);
c->sort(0);
cout << "After sort:" << endl;
c->print(0);
delete c;
}
catch (exception e)
{
cout << e.what() << endl;
}
getchar();
return 0;
}

    J'ai omis le contrôle de la portée pour des raisons de simplicité.
    Sortie:

    Before sort:
hello
pear
apple
After sort:
apple
hello
pear
    C'est ce que j'avais à l'origine, mais depuis les cordes peuvent changer, ils changent les emplacements de la mémoire. C'était une douleur pour trouver ce bug.
    J'ai mis à jour ma réponse. Maintenant, il est possible de changer les cordes dans words.
    Merci pour la méthode. Je comprends ce que vous vouliez dire, mais cela nécessiterait un autre re-re-facteur de mon programme, tandis que les Prive de la solution ne serait pas.

    OriginalL'auteur kol