C++；结构排序 我有一个自定义结构的向量，每次都需要按照不同的标准进行排序 执行运算符但是我希望每次调用C++标准排序时都能指定排序标准。

怎么做

• 请注意，运行时间最好是高效的

---

谢谢

您可以使用第三个参数定义在每次运行排序算法时要使用的比较函数：

template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
          StrictWeakOrdering comp);

模板
无效排序（首先是RandomAccessIterator，最后是RandomAccessIterator，
严格的管理；

一个简单的例子：

struct person {
   std::string name;
   int age;
};
bool sort_by_name( const person & lhs, const person & rhs )
{
   return lhs.name < rhs.name;
}
bool sort_by_age( const person & lhs, const person & rhs )
{
   return lhs.age < rhs.age;
}
int main() {
   std::vector<person> people;
   // fill in the vector
   std::sort( people.begin(), people.end(), sort_by_name );
   std::sort( people.begin(), people.end(), sort_by_age );
}

struct-person{
std：：字符串名；
智力年龄；
};
bool按名称排序（const person和lhs、const person和rhs）
{
返回lhs.name

您可以使用第三个参数定义在每次运行排序算法时要使用的比较函数：

template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
          StrictWeakOrdering comp);

模板
无效排序（首先是RandomAccessIterator，最后是RandomAccessIterator，
严格的管理；

一个简单的例子：

struct person {
   std::string name;
   int age;
};
bool sort_by_name( const person & lhs, const person & rhs )
{
   return lhs.name < rhs.name;
}
bool sort_by_age( const person & lhs, const person & rhs )
{
   return lhs.age < rhs.age;
}
int main() {
   std::vector<person> people;
   // fill in the vector
   std::sort( people.begin(), people.end(), sort_by_name );
   std::sort( people.begin(), people.end(), sort_by_age );
}

struct-person{
std：：字符串名；
智力年龄；
};
bool按名称排序（const person和lhs、const person和rhs）
{
返回lhs.name

有两个版本的

std:：sort

，第二个版本接受比较函子：

template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
          StrictWeakOrdering comp);
//--------^^^^^^^^^^^^^^^^^^^^^^^

模板
无效排序（首先是RandomAccessIterator，最后是RandomAccessIterator，
严格的管理；
//--------^^^^^^^^^^^^^^^^^^^^^^^

例如：

bool isLessThan(const MyStruct& first, const MyStruct& second) {
   if (first.name < second.name) return true;
   else if (first.name == second.name) {
      if (first.date > second.date) return true;
      // etc.
   }
   return false;
}

...

sort(v.begin(), v.end(), isLessThan);

bool mycomparator(const T& a, const T&b); // return true if a < b

bool isLessThan（const MyStruct&first，const MyStruct&second）{
if（first.namesecond.date）返回true；
//等等。
}
返回false；
}
...
排序（v.begin（）、v.end（）、isLessThan）；

另见

---

此变体仍然使用相同的快速排序算法，因此平均为O（n log n）。

有两个版本的

std:：sort

，第二个版本接受比较函子：

template <class RandomAccessIterator, class StrictWeakOrdering>
void sort(RandomAccessIterator first, RandomAccessIterator last,
          StrictWeakOrdering comp);
//--------^^^^^^^^^^^^^^^^^^^^^^^

模板
无效排序（首先是RandomAccessIterator，最后是RandomAccessIterator，
严格的管理；
//--------^^^^^^^^^^^^^^^^^^^^^^^

例如：

bool isLessThan(const MyStruct& first, const MyStruct& second) {
   if (first.name < second.name) return true;
   else if (first.name == second.name) {
      if (first.date > second.date) return true;
      // etc.
   }
   return false;
}

...

sort(v.begin(), v.end(), isLessThan);

bool mycomparator(const T& a, const T&b); // return true if a < b

bool isLessThan（const MyStruct&first，const MyStruct&second）{
if（first.namesecond.date）返回true；
//等等。
}
返回false；
}
...
排序（v.begin（）、v.end（）、isLessThan）；

另见

此变体仍然使用相同的快速排序算法，因此平均为O（n log n）。

有两个版本，第一个版本仅使用迭代器并使用对象的运算符<重载，而第二个版本允许您指定一个比较器对象来执行比较。您只需要提供一个符合比较器概念的类。comparator对象（或函数）应该可以用两个参数调用，其中每个参数都是指定的类型，如果第一个参数小于第二个参数，则应该返回true。例如：

bool isLessThan(const MyStruct& first, const MyStruct& second) {
   if (first.name < second.name) return true;
   else if (first.name == second.name) {
      if (first.date > second.date) return true;
      // etc.
   }
   return false;
}

...

sort(v.begin(), v.end(), isLessThan);

bool mycomparator(const T& a, const T&b); // return true if a < b 布尔MyCompariator（常数T&a，常数T&b）；//如果a 类比较器 { 公众： bool操作符（）（常量T&a，常量T&b）const；//如果a

bool isLessThan(const MyStruct& first, const MyStruct& second) {
   if (first.name < second.name) return true;
   else if (first.name == second.name) {
      if (first.date > second.date) return true;
      // etc.
   }
   return false;
}

...

sort(v.begin(), v.end(), isLessThan);

bool mycomparator(const T& a, const T&b); // return true if a < b 布尔MyCompariator（常数T&a，常数T&b）；//如果a 类比较器 { 公众： bool操作符（）（常量T&a，常量T&b）const；//如果a为了完整起见，下面是一个使用c++0x lambda函数的示例：

std::vector<Person> v;
std::sort(v.begin(), v.end(), [](Person a, Person b) { return a.name_ < b.name_; });
...
std::sort(v.begin(), v.end(), [](Person a, Person b) { return a.address_ < b.address_; });

std:：vector v；
std:：sort（v.begin（），v.end（），[]（persona，personb）{returna.name{b.name}）；
...
std:：sort（v.begin（），v.end（），[]（persona，personb）{returna.address}

为了完整起见，下面是一个使用c++0x lambda函数的示例：

std::vector<Person> v;
std::sort(v.begin(), v.end(), [](Person a, Person b) { return a.name_ < b.name_; });
...
std::sort(v.begin(), v.end(), [](Person a, Person b) { return a.address_ < b.address_; });

std:：vector v；
std:：sort（v.begin（），v.end（），[]（persona，personb）{returna.name{b.name}）；
...
std:：sort（v.begin（），v.end（），[]（persona，personb）{returna.address}

允许在简单情况下就地定义比较函数：

#include <iostream>
#include <algorithm>

#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/bind.hpp>

#define P(a) do {                                                       \
    BOOST_FOREACH (Struct s, a)                                         \
      std::cout << boost::format("(%d %c) ") % s.i % s.c;               \
    std::cout << std::endl;                                             \
  } while(0)

namespace {
  struct Struct { int i; char c; };
}

int main() {
  using boost::bind;

  Struct a[] = { 1, 'z', 2, 'a' }; P(a);
  const int N = sizeof(a) / sizeof(*a);

  std::sort(a, a + N, bind(&Struct::i, _1) > bind(&Struct::i, _2));  P(a);
  std::sort(a, a + N, bind(&Struct::c, _1) > bind(&Struct::c, _2));  P(a);
}

允许在简单情况下就地定义比较函数：

#include <iostream>
#include <algorithm>

#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/bind.hpp>

#define P(a) do {                                                       \
    BOOST_FOREACH (Struct s, a)                                         \
      std::cout << boost::format("(%d %c) ") % s.i % s.c;               \
    std::cout << std::endl;                                             \
  } while(0)

namespace {
  struct Struct { int i; char c; };
}

int main() {
  using boost::bind;

  Struct a[] = { 1, 'z', 2, 'a' }; P(a);
  const int N = sizeof(a) / sizeof(*a);

  std::sort(a, a + N, bind(&Struct::i, _1) > bind(&Struct::i, _2));  P(a);
  std::sort(a, a + N, bind(&Struct::c, _1) > bind(&Struct::c, _2));  P(a);
}

---

对于boost答案：如果不需要使用向量，请查看boost的多索引容器，以便对容器有不同的视图：对于boost答案：如果不需要使用向量，请查看boost的多索引容器，以便对容器有不同的视图：顺便说一句，您可以在此处检查实用程序模板以避免自己编写函子：顺便说一句，您可以在此处检查实用程序模板以避免自己编写函子：