blocks|key|4904044|text|使用std::sort和一个函数器。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4904045|struct+SortByX
{
+++bool+operator()+const+(MyClass+const+&+L,+MyClass+const+&+R)+{+return+L.x+<+R.x;+}
};

std::sort(vec.begin(),+vec.end(),+SortByX());|code-block|syntax|javascript|4904046|对于您期望的排序顺序，如果L小于R，函数器的运算符()应返回true。|4904047|entityMap^0|2|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Use <code>std::sort</code> and a functor. e.g:

<pre><code>struct SortByX
{
 bool operator() const (MyClass const &amp; L, MyClass const &amp; R) { return L.x &lt; R.x; }
};

std::sort(vec.begin(), vec.end(), SortByX());
</code></pre>

The functor's operator() should return true if L is less than R for the sort order you desire.

blocks|key|4904082|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4904083|有几个不同的对象和几个不同的属性可以对其进行排序。|blockquote|4904084|4904085|4904086|虽然Erik发布的解决方案是正确的，但这句话让我认为，如果你实际上计划在同一个程序中以多种方式对多个类的多个公共数据成员进行排序，那么它是不切实际的，因为每个排序方法都需要自己的函数器类型。|4904087|我推荐以下抽象：|4904088|#include+<functional>

template<typename+C,+typename+M,+template<typename>+class+Pred+=+std::less>
struct+member_comparer+:+std::binary_function<C,+C,+bool>+{
++++explicit+member_comparer(M+C::*ptr)+:+ptr_{ptr}+{+}

++++bool+operator+()(C+const&+lhs,+C+const&+rhs)+const+{
++++++++return+Pred<M>{}(lhs.*ptr_,+rhs.*ptr_);
++++}

private:
++++M+C::*ptr_;
};

template<template<typename>+class+Pred+=+std::less,+typename+C,+typename+M>
member_comparer<C,+M,+Pred>+make_member_comparer(M+C::*ptr)+{
++++return+member_comparer<C,+M,+Pred>{ptr};
}|code-block|syntax|javascript|4904089|用法如下所示：|4904090|#include+<algorithm>
#include+<string>
#include+<vector>

struct+MyClass+{
++++int+++++++++i;
++++std::string+s;

++++MyClass(int+i_,+std::string+const&+s_)+:+i{i_},+s{s_}+{+}
};

int+main()+{
++++std::vector<MyClass>+vec;
++++vec.emplace_back(2,+"two");
++++vec.emplace_back(8,+"eight");

++++//+sort+by+i,+ascending
++++std::sort(vec.begin(),+vec.end(),+make_member_comparer(&MyClass::i));
++++//+sort+by+s,+ascending
++++std::sort(vec.begin(),+vec.end(),+make_member_comparer(&MyClass::s));
++++//+sort+by+s,+descending
++++std::sort(vec.begin(),+vec.end(),+make_member_comparer<std::greater>(&MyClass::s));
}|4904091|这将适用于任何具有公共数据成员的类型，并且如果您需要以多种不同的方式对类进行排序，则可以节省大量的输入。|4904092|下面是一个使用公共成员函数而不是公共数据成员的变体：|4904093|#include+<functional>

template<typename+C,+typename+M,+template<typename>+class+Pred+=+std::less>
struct+method_comparer+:+std::binary_function<C,+C,+bool>+{
++++explicit+method_comparer(M+(C::*ptr)()+const)+:+ptr_{ptr}+{+}

++++bool+operator+()(C+const&+lhs,+C+const&+rhs)+const+{
++++++++return+Pred<M>{}((lhs.*ptr_)(),+(rhs.*ptr_)());
++++}

private:
++++M+(C::*ptr_)()+const;
};

template<template<typename>+class+Pred+=+std::less,+typename+C,+typename+M>
method_comparer<C,+M,+Pred>+make_method_comparer(M+(C::*ptr)()+const)+{
++++return+method_comparer<C,+M,+Pred>{ptr};
}|4904094|用法如下：|4904095|#include+<algorithm>
#include+<string>
#include+<vector>

class+MyClass+{
++++int+++++++++i_;
++++std::string+s_;

public:
++++MyClass(int+i,+std::string+const&+s)+:+i_{i},+s_{s}+{+}

++++int++++++++++++++++i()+const+{+return+i_;+}
++++std::string+const&+s()+const+{+return+s_;+}
};

int+main()+{
++++std::vector<MyClass>+vec;
++++vec.emplace_back(2,+"two");
++++vec.emplace_back(8,+"eight");

++++//+sort+by+i(),+ascending
++++std::sort(vec.begin(),+vec.end(),+make_method_comparer(&MyClass::i));
++++//+sort+by+s(),+ascending
++++std::sort(vec.begin(),+vec.end(),+make_method_comparer(&MyClass::s));
++++//+sort+by+s(),+descending
++++std::sort(vec.begin(),+vec.end(),+make_method_comparer<std::greater>(&MyClass::s));
}|4904096|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|14|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|15|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|16|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|17|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|18|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|19|7|@]|8|@]|9|$]]|$1|J|3|K|4|L|6|1A|7|@]|8|@]|9|$M|N]]|$1|O|3|P|4|5|6|1B|7|@]|8|@]|9|$]]|$1|Q|3|R|4|L|6|1C|7|@]|8|@]|9|$M|N]]|$1|S|3|T|4|5|6|1D|7|@]|8|@]|9|$]]|$1|U|3|V|4|5|6|1E|7|@]|8|@]|9|$]]|$1|W|3|X|4|L|6|1F|7|@]|8|@]|9|$M|N]]|$1|Y|3|Z|4|5|6|1G|7|@]|8|@]|9|$]]|$1|10|3|11|4|L|6|1H|7|@]|8|@]|9|$M|N]]|$1|12|3|-4|4|5|6|1I|7|@]|8|@]|9|$]]]|13|$]]

<blockquote>
There are several different objects and several different properties that could it be sorted by.
</blockquote>
While the solution Erik posted is correct, this statement leads me to think that it's impractical at best if you are in fact planning to sort by multiple public data members of multiple classes in multiple ways in the same program, as each sorting method will require its own functor type.
I recommend the following abstraction:
<pre><code>#include &lt;functional&gt;

template&lt;typename C, typename M, template&lt;typename&gt; class Pred = std::less&gt;
struct member_comparer : std::binary_function&lt;C, C, bool&gt; {
 explicit member_comparer(M C::*ptr) : ptr_{ptr} { }

 bool operator ()(C const&amp; lhs, C const&amp; rhs) const {
 return Pred&lt;M&gt;{}(lhs.*ptr_, rhs.*ptr_);
 }

private:
 M C::*ptr_;
};

template&lt;template&lt;typename&gt; class Pred = std::less, typename C, typename M&gt;
member_comparer&lt;C, M, Pred&gt; make_member_comparer(M C::*ptr) {
 return member_comparer&lt;C, M, Pred&gt;{ptr};
}
</code></pre>
Usage would look like:
<pre><code>#include &lt;algorithm&gt;
#include &lt;string&gt;
#include &lt;vector&gt;

struct MyClass {
 int i;
 std::string s;

 MyClass(int i_, std::string const&amp; s_) : i{i_}, s{s_} { }
};

int main() {
 std::vector&lt;MyClass&gt; vec;
 vec.emplace_back(2, &quot;two&quot;);
 vec.emplace_back(8, &quot;eight&quot;);

 // sort by i, ascending
 std::sort(vec.begin(), vec.end(), make_member_comparer(&amp;MyClass::i));
 // sort by s, ascending
 std::sort(vec.begin(), vec.end(), make_member_comparer(&amp;MyClass::s));
 // sort by s, descending
 std::sort(vec.begin(), vec.end(), make_member_comparer&lt;std::greater&gt;(&amp;MyClass::s));
}
</code></pre>
This will work for any type with public data members, and will save a lot of typing if you need to sort your classes more than a couple of different ways.
Here is a variation that works with public member functions instead of public data members:
<pre><code>#include &lt;functional&gt;

template&lt;typename C, typename M, template&lt;typename&gt; class Pred = std::less&gt;
struct method_comparer : std::binary_function&lt;C, C, bool&gt; {
 explicit method_comparer(M (C::*ptr)() const) : ptr_{ptr} { }

 bool operator ()(C const&amp; lhs, C const&amp; rhs) const {
 return Pred&lt;M&gt;{}((lhs.*ptr_)(), (rhs.*ptr_)());
 }

private:
 M (C::*ptr_)() const;
};

template&lt;template&lt;typename&gt; class Pred = std::less, typename C, typename M&gt;
method_comparer&lt;C, M, Pred&gt; make_method_comparer(M (C::*ptr)() const) {
 return method_comparer&lt;C, M, Pred&gt;{ptr};
}
</code></pre>
With usage like:
<pre><code>#include &lt;algorithm&gt;
#include &lt;string&gt;
#include &lt;vector&gt;

class MyClass {
 int i_;
 std::string s_;

public:
 MyClass(int i, std::string const&amp; s) : i_{i}, s_{s} { }

 int i() const { return i_; }
 std::string const&amp; s() const { return s_; }
};

int main() {
 std::vector&lt;MyClass&gt; vec;
 vec.emplace_back(2, &quot;two&quot;);
 vec.emplace_back(8, &quot;eight&quot;);

 // sort by i(), ascending
 std::sort(vec.begin(), vec.end(), make_method_comparer(&amp;MyClass::i));
 // sort by s(), ascending
 std::sort(vec.begin(), vec.end(), make_method_comparer(&amp;MyClass::s));
 // sort by s(), descending
 std::sort(vec.begin(), vec.end(), make_method_comparer&lt;std::greater&gt;(&amp;MyClass::s));
}
</code></pre>

blocks|key|4904135|text|编辑:替换为lambda_compare，因为我是受虐狂：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4904136|您也可以只创建一个帮助器，让您通过lambda表达式指定要使用的值：|4904137|template+<class+F>+class+lambda_compare
{
public:
++++lambda_compare(F+f_):+f(f_)+{+}
++++template+<class+T>+bool+operator()(const+T+&lhs,+const+T+&rhs)+const
++++{+return+f(lhs)<f(rhs);+}

private:
++++F+f;
};

template+<class+F>+lambda_compare<F>+make_lambda_compare(F+f)
{+return+f;+}

...
std::sort(vec.begin(),+vec.end(),+make_lambda_compare([](const+foo+&value)+{+return+value.member;+}));|code-block|syntax|javascript|4904138|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

EDIT: replacing with lambda_compare, because I'm a masochist:

You can also just create a helper that lets you specify which value to use via a lambda expression:

<pre><code>template &lt;class F&gt; class lambda_compare
{
public:
 lambda_compare(F f_): f(f_) { }
 template &lt;class T&gt; bool operator()(const T &amp;lhs, const T &amp;rhs) const
 { return f(lhs)&lt;f(rhs); }

private:
 F f;
};

template &lt;class F&gt; lambda_compare&lt;F&gt; make_lambda_compare(F f)
{ return f; }

...
std::sort(vec.begin(), vec.end(), make_lambda_compare([](const foo &amp;value) { return value.member; }));
</code></pre>

blocks|key|1968524|text|这是我的答案，只需使用lambda函数！它工作，它使用了更少的代码，在我看来它是优雅的！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1968525|#include+<algorithm>
#include+<vector>
#include+<string>

struct+MyClass
{
++++int+i;
++++std::string+s;

++++MyClass(int+i_,+std::string+const&+s_)+:+i(i_),+s(s_)+{+}
};

int+main()
{
++++std::vector<MyClass>+vec;
++++vec.push_back(MyClass(2,+"two"));
++++vec.push_back(MyClass(8,+"eight"));

++++//+sort+by+i,+ascending
++++std::sort(vec.begin(),+vec.end(),+[](MyClass+a,+MyClass+b){+return+a.i+<+b.i;+});
++++//+sort+by+s,+ascending
++++std::sort(vec.begin(),+vec.end(),+[](MyClass+a,+MyClass+b){+return+a.s+<+b.s;+});
++++//+sort+by+s,+descending
++++std::sort(vec.begin(),+vec.end(),+[](MyClass+a,+MyClass+b){+return+a.s+>+b.s;+});
}|code-block|syntax|javascript|1968526|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my version of the answer, just use a lambda function! It works, it uses way less code, and in my opinion it's elegant! 

<pre><code>#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;string&gt;

struct MyClass
{
 int i;
 std::string s;

 MyClass(int i_, std::string const&amp; s_) : i(i_), s(s_) { }
};

int main()
{
 std::vector&lt;MyClass&gt; vec;
 vec.push_back(MyClass(2, "two"));
 vec.push_back(MyClass(8, "eight"));

 // sort by i, ascending
 std::sort(vec.begin(), vec.end(), [](MyClass a, MyClass b){ return a.i &lt; b.i; });
 // sort by s, ascending
 std::sort(vec.begin(), vec.end(), [](MyClass a, MyClass b){ return a.s &lt; b.s; });
 // sort by s, descending
 std::sort(vec.begin(), vec.end(), [](MyClass a, MyClass b){ return a.s &gt; b.s; });
}
</code></pre>

blocks|key|4904161|text|sort(v.begin(),+v.end(),+[](const+Car*+lhs,+const+Car*+rhs)+{
+++++return+lhs->getPassengers()+<+rhs->getPassengers();
+});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4904162|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>sort(v.begin(), v.end(), [](const Car* lhs, const Car* rhs) {
 return lhs-&gt;getPassengers() &lt; rhs-&gt;getPassengers();
 });
</code></pre>

I'm working on a project for school and need to sort some data. I've been given a vector of objects and I have to sort the objects (either in place or using an index) based on one of their properties. There are several different objects and several different properties that could it be sorted by. What's the best way to go about doing this?

Sorting a vector of objects by a property of the object

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在为学校做一个项目，需要整理一些数据。我得到了一个对象的向量，我必须根据对象的一个属性对对象进行排序(就地或使用索引)。有几个不同的对象和几个不同的属性可以对其进行排序。做这件事最好的方法是什么？

问根据对象的属性对对象的向量进行排序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问根据对象的属性对对象的向量进行排序EN