Comment sortinger un vecteur STL?

Je voudrais sortinger un vector

 vector object; 

myclass contient de nombreuses variables int . Comment puis-je sortinger mon vector sur une variable de données spécifique de myClass ?

Surcharger moins que l’opérateur, puis sortinger. Ceci est un exemple que j’ai trouvé sur le web …

 class MyData { public: int m_iData; ssortingng m_strSomeOtherData; bool operator< (const MyData &rhs) const { return m_iData < rhs.m_iData; } }; std::sort(myvector.begin(), myvector.end()); 

Source: ici

 std::sort(object.begin(), object.end(), pred()); 

where, pred() est un object fonction définissant l’ordre sur les objects de myclass . Vous pouvez également définir myclass::operator< .

Par exemple, vous pouvez passer un lambda:

 std::sort(object.begin(), object.end(), [] (myclass const& a, myclass const& b) { return av < bv; }); 

Ou si vous êtes coincé avec C ++ 03, l'approche de l'object fonction ( v est le membre sur lequel vous voulez sortinger):

 struct pred { bool operator()(myclass const & a, myclass const & b) const { return av < bv; } }; 

Un pointeur sur membre vous permet d’écrire un seul comparateur, qui peut fonctionner avec n’importe quel membre de données de votre classe:

 #include  #include  #include  #include  template  struct CompareByMember { // This is a pointer-to-member, it represents a member of class T // The data member has type U UT::*field; CompareByMember(UT::*f) : field(f) {} bool operator()(const T &lhs, const T &rhs) { return lhs.*field < rhs.*field; } }; struct Test { int a; int b; std::string c; Test(int a, int b, std::string c) : a(a), b(b), c(c) {} }; // for convenience, this just lets us print out a Test object std::ostream &operator<<(std::ostream &o, const Test &t) { return o << tc; } int main() { std::vector vec; vec.push_back(Test(1, 10, "y")); vec.push_back(Test(2, 9, "x")); // sort on the ssortingng field std::sort(vec.begin(), vec.end(), CompareByMember(&Test::c)); std::cout < < "sorted by string field, c: "; std::cout << vec[0] << " " << vec[1] << "\n"; // sort on the first integer field std::sort(vec.begin(), vec.end(), CompareByMember(&Test::a)); std::cout < < "sorted by integer field, a: "; std::cout << vec[0] << " " << vec[1] << "\n"; // sort on the second integer field std::sort(vec.begin(), vec.end(), CompareByMember(&Test::b)); std::cout < < "sorted by integer field, b: "; std::cout << vec[0] << " " << vec[1] << "\n"; } 

Sortie:

 sorted by ssortingng field, c: xy sorted by integer field, a: yx sorted by integer field, b: xy 

Comme expliqué dans d’autres réponses, vous devez fournir une fonction de comparaison. Si vous souhaitez conserver la définition de cette fonction près de l’appel de sort (par exemple, si elle n’a de sens que pour ce type), vous pouvez la définir directement avec boost::lambda . Utilisez boost::lambda::bind pour appeler la fonction membre.

Pour sortinger par exemple une variable membre ou une fonction data1 :

 #include  #include  #include  #include  using boost::lambda::bind; using boost::lambda::_1; using boost::lambda::_2; std::vector object(10000); std::sort(object.begin(), object.end(), bind(&myclass::data1, _1) < bind(&myclass::data1, _2)); 

C’est mon approche pour résoudre cela en général. Il étend la réponse de Steve Jessop en supprimant la nécessité de définir explicitement les arguments de modèle et en ajoutant l’option permettant également d’utiliser des functoins et des pointeurs pour les méthodes (getters).

 #include  #include  #include  #include  #include  using namespace std; template  struct CompareByGetter { U (T::*getter)() const; CompareByGetter(U (T::*getter)() const) : getter(getter) {}; bool operator()(const T &lhs, const T &rhs) { (lhs.*getter)() < (rhs.*getter)(); } }; template  CompareByGetter by(U (T::*getter)() const) { return CompareByGetter(getter); } //// sort_by template  struct CompareByMember { UT::*field; CompareByMember(UT::*f) : field(f) {} bool operator()(const T &lhs, const T &rhs) { return lhs.*field < rhs.*field; } }; template  CompareByMember by(UT::*f) { return CompareByMember(f); } template  struct CompareByFunction { function f; CompareByFunction(function f) : f(f) {} bool operator()(const T& a, const T& b) const { return f(a) < f(b); } }; template  CompareByFunction by(function f) { CompareByFunction cmp{f}; return cmp; } struct mystruct { double x,y,z; ssortingng name; double length() const { return sqrt( x*x + y*y + z*z ); } }; ostream& operator< < (ostream& os, const mystruct& ms) { return os << "{ " << ms.x << ", " << ms.y << ", " << ms.z << ", " << ms.name << " len: " << ms.length() << "}"; } template  ostream& operator< < (ostream& os, std::vector v) { os < < "["; for (auto it = begin(v); it != end(v); ++it) { if ( it != begin(v) ) { os << " "; } os << *it; } os << "]"; return os; } void sorting() { vector vec1 = { {1,1,0,"a"}, {0,1,2,"b"}, {-1,-5,0,"c"}, {0,0,0,"d"} }; function f = [](const mystruct& v){return v.name;}; cout < < "unsorted " << vec1 << endl; sort(begin(vec1), end(vec1), by(&mystruct::x) ); cout << "sort_by x " << vec1 << endl; sort(begin(vec1), end(vec1), by(&mystruct::length)); cout << "sort_by len " << vec1 << endl; sort(begin(vec1), end(vec1), by(f) ); cout << "sort_by name " << vec1 << endl; }