blocks|key|1817695|text|最好的方法是有一个结构，把名字和分数结合起来，并有一个向量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817696|struct+Person
{
++++std::string+Name;
++++int+Score;
};|code-block|syntax|javascript|1817697|然后你可以声明你的向量：|1817698|std::vector<Person>+people{+{+"Karl",+45+},+{+"Martin",+5+},+{+"Paul",+14+}+};|1817699|使用std::sort从<algorithm>中进行排序很容易|offset|length|style|CODE|1817700|std::sort(people.begin(),+people.end(),+
+++++++++++++++[](const+auto&+i,+const+auto&+j)+{+return+i.Score+<+j.Score;+}+);|1817701|如果要按降序排序，也可以更改lambda：|1817702|std::sort(people.begin(),+people.end(),+
+++++++++++++++[](const+auto&+i,+const+auto&+j)+{+return+i.Score+>+j.Score;+}+);|1817703|entityMap^0|0|0|0|0|2|9|C|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@$M|13|N|14|O|P]|$M|15|N|16|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

Best way to do this would be to have a struct which combines the names with their scores and have one vector.

<pre><code>struct Person
{
 std::string Name;
 int Score;
};
</code></pre>

Then you can declare your vector:

<pre><code>std::vector&lt;Person&gt; people{ { "Karl", 45 }, { "Martin", 5 }, { "Paul", 14 } };
</code></pre>

And sorting it is easy with <code>std::sort</code> from <code>&lt;algorithm&gt;</code>:

<pre><code>std::sort(people.begin(), people.end(), 
 [](const auto&amp; i, const auto&amp; j) { return i.Score &lt; j.Score; } );
</code></pre>

Or you can change the lambda if you want to sort in descending order:

<pre><code>std::sort(people.begin(), people.end(), 
 [](const auto&amp; i, const auto&amp; j) { return i.Score &gt; j.Score; } );
</code></pre>

blocks|key|935836|text|您可以这样做的一种方法是将名称和分数存储在单个数据结构(如std::vector<std::pair<std::string,int>>+)中，然后按以下方式进行排序：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|935837|#include+<algorithm>
#include+<vector>
#include+<string>
#include+<utility>
//...
std::vector<std::pair<std::string,+int>>+names_scores_vec;
//+...+populate+names_scores_vec...
//+lambda+for+sorting,+change+to+>+for+descending+order
auto+sort_by_scores+=+[](const+std::pair<string,int>&+_lhs,+
++++const+std::pair<string,int>&+_rhs)+{+return+_lhs.second+<+_rhs.second;+};
std::sort(names_scores_vec.begin(),+names_scores_vec.end(),+sort_by_scores);|code-block|syntax|javascript|935838|或者，如果您想要重复的键(即允许重复的名称)，则使用诸如std::map或std::multimap之类的存储。|935839|entityMap^0|T|13|0|0|S|8|11|D|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|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

One way you could do this would be to store the Names and Scores in a single data structure such as a <code>std::vector&lt;std::pair&lt;std::string,int&gt;&gt;</code> and then sorting can be done as follows:

<pre><code>#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;utility&gt;
//...
std::vector&lt;std::pair&lt;std::string, int&gt;&gt; names_scores_vec;
// ... populate names_scores_vec...
// lambda for sorting, change to &gt; for descending order
auto sort_by_scores = [](const std::pair&lt;string,int&gt;&amp; _lhs, 
 const std::pair&lt;string,int&gt;&amp; _rhs) { return _lhs.second &lt; _rhs.second; };
std::sort(names_scores_vec.begin(), names_scores_vec.end(), sort_by_scores);
</code></pre>

Alternatively, use storage such as a <code>std::map</code> or <code>std::multimap</code> if you want repeated keys (i.e. repeated names allowed).

blocks|key|1064112|text|如果不能将数据合并为成对的向量或两者的结构，则可以创建迭代器的向量，或0到size-1之间的索引。然后使用自定义比较器对其进行排序。最后，创建一个新的向量，使用迭代器或索引填充它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1064113|template<class+T1,+class+A1,+class+T2,+class+A2>
std::vector<T1,+A1>+sort_by(
++std::vector<T1,A1>+const&+vin,+std::vector<T2,A2>+const&+keys
){
++std::vector<std::size_t>+is;
++is.reserve(vin.size());
++for+(auto&&+unused:keys)
++++is.push_back(is.size());
++std::sort(begin(is),end(is),[&](std::size_t+l,+std::size_t+r){
++++return+keys[l]<keys[r];
++});
++std::vector<T1,+A1>+r;
++r.reserve(vin.size());
++for(std::size_t+i:is)
++++r.push_back(vin[i]);
++return+r;
}|code-block|syntax|javascript|1064114|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|$]]

If you cannot merge the data into a vector of pairs or struct with both, you could create a vector of iterators, or the indexes from 0 to size-1. Then sort this using a custom comparator. Finally, create a new vector, populating it using the iterators or indexes.

<pre><code>template&lt;class T1, class A1, class T2, class A2&gt;
std::vector&lt;T1, A1&gt; sort_by(
 std::vector&lt;T1,A1&gt; const&amp; vin, std::vector&lt;T2,A2&gt; const&amp; keys
){
 std::vector&lt;std::size_t&gt; is;
 is.reserve(vin.size());
 for (auto&amp;&amp; unused:keys)
 is.push_back(is.size());
 std::sort(begin(is),end(is),[&amp;](std::size_t l, std::size_t r){
 return keys[l]&lt;keys[r];
 });
 std::vector&lt;T1, A1&gt; r;
 r.reserve(vin.size());
 for(std::size_t i:is)
 r.push_back(vin[i]);
 return r;
}
</code></pre>

blocks|key|1064130|text|正如其他答案中已经提到的:将每个人的名字和分数结合起来可能是最简单的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1064131|一般说来，这可以通过有时被称为"zip“操作来实现:将两个向量组合成一个对向量--以及相应的”解压缩“。|1064132|一般说来，这可能如下所示：|1064133|#include+<vector>
#include+<string>
#include+<algorithm>
#include+<iostream>
#include+<iterator>

//+Fill+the+zipped+vector+with+pairs+consisting+of+the
//+corresponding+elements+of+a+and+b.+(This+assumes+
//+that+the+vectors+have+equal+length)
template+<typename+A,+typename+B>
void+zip(
++++const+std::vector<A>+&a,+
++++const+std::vector+&b,+
++++std::vector<std::pair<A,B>>+&zipped)
{
++++for(size_t+i=0;+i<a.size();+%2B%2Bi)
++++{
++++++++zipped.push_back(std::make_pair(a[i],+b[i]));
++++}
}

//+Write+the+first+and+second+element+of+the+pairs+in+
//+the+given+zipped+vector+into+a+and+b.+(This+assumes+
//+that+the+vectors+have+equal+length)
template+<typename+A,+typename+B>
void+unzip(
++++const+std::vector<std::pair<A,+B>>+&zipped,+
++++std::vector<A>+&a,+
++++std::vector+&b)
{
++++for(size_t+i=0;+i<a.size();+i%2B%2B)
++++{
++++++++a[i]+=+zipped[i].first;
++++++++b[i]+=+zipped[i].second;
++++}
}


int+main(int+argc,+char*+argv[])
{
++++std::vector<std::string>+names+{"Karl",+"Martin",+"Paul",+"Jennie"};
++++std::vector<int>+score+{45,+5,+14,+24};

++++//+Zip+the+vectors+together
++++std::vector<std::pair<std::string,int>>+zipped;
++++zip(names,+score,+zipped);

++++//+Sort+the+vector+of+pairs
++++std::sort(std::begin(zipped),+std::end(zipped),+
++++++++[&](const+auto&+a,+const+auto&+b)
++++++++{
++++++++++++return+a.second+>+b.second;
++++++++});

++++//+Write+the+sorted+pairs+back+to+the+original+vectors
++++unzip(zipped,+names,+score);

++++for(size_t+i=0;+i<names.size();+i%2B%2B)
++++{
++++++++std::cout+<<+names[i]+<<+"+:+"+<<+score[i]+<<+std::endl;
++++}
++++return+0;
}|code-block|syntax|javascript|1064134|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

As already suggested in other answers: Combining the name and the score of each individual is likely the simplest solution. 

Generically, this can be achieved with what is sometimes referred to as a "zip" operation: Combining two vectors into a vector of pairs - along with a corresponding "unzip". 

Implemented generically, this may look as follows:

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

// Fill the zipped vector with pairs consisting of the
// corresponding elements of a and b. (This assumes 
// that the vectors have equal length)
template &lt;typename A, typename B&gt;
void zip(
 const std::vector&lt;A&gt; &amp;a, 
 const std::vector&lt;B&gt; &amp;b, 
 std::vector&lt;std::pair&lt;A,B&gt;&gt; &amp;zipped)
{
 for(size_t i=0; i&lt;a.size(); ++i)
 {
 zipped.push_back(std::make_pair(a[i], b[i]));
 }
}

// Write the first and second element of the pairs in 
// the given zipped vector into a and b. (This assumes 
// that the vectors have equal length)
template &lt;typename A, typename B&gt;
void unzip(
 const std::vector&lt;std::pair&lt;A, B&gt;&gt; &amp;zipped, 
 std::vector&lt;A&gt; &amp;a, 
 std::vector&lt;B&gt; &amp;b)
{
 for(size_t i=0; i&lt;a.size(); i++)
 {
 a[i] = zipped[i].first;
 b[i] = zipped[i].second;
 }
}


int main(int argc, char* argv[])
{
 std::vector&lt;std::string&gt; names {"Karl", "Martin", "Paul", "Jennie"};
 std::vector&lt;int&gt; score {45, 5, 14, 24};

 // Zip the vectors together
 std::vector&lt;std::pair&lt;std::string,int&gt;&gt; zipped;
 zip(names, score, zipped);

 // Sort the vector of pairs
 std::sort(std::begin(zipped), std::end(zipped), 
 [&amp;](const auto&amp; a, const auto&amp; b)
 {
 return a.second &gt; b.second;
 });

 // Write the sorted pairs back to the original vectors
 unzip(zipped, names, score);

 for(size_t i=0; i&lt;names.size(); i++)
 {
 std::cout &lt;&lt; names[i] &lt;&lt; " : " &lt;&lt; score[i] &lt;&lt; std::endl;
 }
 return 0;
}
</code></pre>

blocks|key|1817846|text|这不能通过自定义迭代器类型来完成吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817847|编辑：|1817848|我所想的最简单的形式是，根据第一个向量对一对向量进行排序，即有一个迭代器，它的函数如去引用、订阅、成员访问和相等，以及排序比较将调用第一个迭代器上的相应函数、所有其他函数(复制、算术、交换、.)对两个迭代器进行操作。|1817849|template+<typename+Driver,+typename+Passenger>
struct+duo_iterator+{+.+.+.+};

template+<typename+D,+typename+P>
auto+make_duo_iterator(D+d,+P+p)+->+duo_iterator<D,+P>+{+.+.+.+}

sort(make_duo_iterator(begin(v1),+begin(v2)),
+++++make_duo_iterator(end(v1),+end(v2)));|code-block|syntax|javascript|1817850|迭代器可以扩展到一个multi_iterator中，以处理任何重排序算法，指向任意数量的额外支持序列。|offset|length|style|CODE|1817851|这可能是个有趣的小项目。或者也许类似的东西已经存在，无论是在Boost还是其他地方。|1817852|EDIT2：|1817853|忘了上面的事。|1817854|Eric的Range-v3库有一个view::zip包装器，“给定N个范围，返回一个新的范围，其中Mth元素是对所有N个范围的Mth元素调用make_tuple的结果。”|1817855|用元组的第一个元素上的谓词对范围进行排序可能只会起到这个作用。|1817856|entityMap|0|LINK|mutability|MUTABLE|url|https://ericniebler.github.io/range-v3/index.html^0|0|0|0|0|A|E|0|0|0|0|H|9|5|9|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1C|8|@$M|1D|N|1E|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1I|8|@$M|1J|N|1K|O|P]]|9|@$M|1L|N|1M|1|1N]]|A|$]]|$1|Y|3|Z|5|6|7|1O|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]]]

Couldn't this be done through a custom iterator type?

EDIT:

What I'm thinking in its simplest form - sorting a pair of vectors based on the first one - is to have an iterator whose functions such as dereferencing, subscripting, member access and equality and ordering comparisons would call the corresponding functions on the first iterator, all other functions (copy, arithmetics, swap, ...) acting on both iterators. 

<pre><code>template &lt;typename Driver, typename Passenger&gt;
struct duo_iterator { . . . };

template &lt;typename D, typename P&gt;
auto make_duo_iterator(D d, P p) -&gt; duo_iterator&lt;D, P&gt; { . . . }

sort(make_duo_iterator(begin(v1), begin(v2)),
 make_duo_iterator(end(v1), end(v2)));
</code></pre>

The iterator could be extended into a <code>multi_iterator</code> to work with any reordering algorithm, pointing into any number of extra piggybacking sequences. 
It could be a fun little project. Or maybe something similar already exists, in Boost or elsewhere.

EDIT2:

Forget the above. 
Eric Niebler's <a href="https://ericniebler.github.io/range-v3/index.html" rel="nofollow">Range-v3 library</a> has a <code>view::zip</code> wrapper that "Given N ranges, return a new range where Mth element is the result of calling make_tuple on the Mth elements of all N ranges." 
Sorting the range with a predicate on the first element of the tuples might just do the trick.

blocks|key|1817907|text|这么多人问这个问题，没有人给出令人满意的答案。下面是一个std::sort，它允许同时对两个向量进行排序，同时考虑到一个向量的值。该解决方案基于自定义的RadomIt+(随机迭代器)，直接对原始矢量数据进行操作，不需要临时副本、结构重排或附加索引：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817908|namespace+std+{

namespace+sort_helper+{

template+<typename+_Data,+typename+_Order>
struct+value_reference_t;

template+<typename+_Data,+typename+_Order>
struct+value_t+{
++++_Data+data;
++++_Order+val;
++++inline+value_t(_Data+_data,+_Order+_val)+:+data(_data),+val(_val)+{}
++++inline+value_t(const+value_reference_t<_Data,_Order>&+rhs);
};

template+<typename+_Data,+typename+_Order>
struct+value_reference_t+{
++++_Data*+pdata;
++++_Order*+pval;
++++value_reference_t(_Data*+_itData,+_Order*+_itVal)+:+pdata(_itData),+pval(_itVal)+{}
++++inline+value_reference_t&+operator+=+(const+value_reference_t&+rhs)+{+*pdata+=+*rhs.pdata;+*pval+=+*rhs.pval;+return+*this;+}
++++inline+value_reference_t&+operator+=+(const+value_t<_Data,_Order>&+rhs)+{+*pdata+=+rhs.data;+*pval+=+rhs.val;+return+*this;+}
++++inline+bool+operator+<+(const+value_reference_t&+rhs)+{+return+*pval+<+*rhs.pval;+}
};

template+<typename+_Data,+typename+_Order>
struct+value_iterator_t+:
++++iterator<+random_access_iterator_tag,+value_t<_Data,_Order>,+ptrdiff_t,+value_t<_Data,_Order>*,+value_reference_t<_Data,_Order>+>
{
++++_Data*+itData;
++++_Order*+itVal;
++++value_iterator_t(_Data*+_itData,+_Order*+_itVal)+:+itData(_itData),+itVal(_itVal)+{}
++++inline+ptrdiff_t+operator+-+(const+value_iterator_t&+rhs)+const+{+return+itVal+-+rhs.itVal;+}
++++inline+value_iterator_t+operator+%2B+(ptrdiff_t+off)+const+{+return+value_iterator_t(itData+%2B+off,+itVal+%2B+off);+}
++++inline+value_iterator_t+operator+-+(ptrdiff_t+off)+const+{+return+value_iterator_t(itData+-+off,+itVal+-+off);+}
++++inline+value_iterator_t&+operator+%2B%2B+()+{+%2B%2BitData;+%2B%2BitVal;+return+*this;+}
++++inline+value_iterator_t&+operator+--+()+{+--itData;+--itVal;+return+*this;+}
++++inline+value_iterator_t+operator+%2B%2B+(int)+{+return+value_iterator_t(itData%2B%2B,+itVal%2B%2B);+}
++++inline+value_iterator_t+operator+--+(int)+{+return+value_iterator_t(itData--,+itVal--);+}
++++inline+value_t<_Data,_Order>+operator+*+()+const+{+return+value_t<_Data,_Order>(*itData,+*itVal);+}
++++inline+value_reference_t<_Data,_Order>+operator+*+()+{+return+value_reference_t<_Data,_Order>(itData,+itVal);+}
++++inline+bool+operator++<+(const+value_iterator_t&+rhs)+const+{+return+itVal++<+rhs.itVal;+}
++++inline+bool+operator+==+(const+value_iterator_t&+rhs)+const+{+return+itVal+==+rhs.itVal;+}
++++inline+bool+operator+!=+(const+value_iterator_t&+rhs)+const+{+return+itVal+!=+rhs.itVal;+}
};

template+<typename+_Data,+typename+_Order>
inline+value_t<_Data,_Order>::value_t(const+value_reference_t<_Data,_Order>&+rhs)
++++:+data(*rhs.pdata),+val(*rhs.pval)+{}

template+<typename+_Data,+typename+_Order>
bool+operator+<+(const+value_t<_Data,_Order>&+lhs,+const+value_reference_t<_Data,_Order>&+rhs)+{
++++return+lhs.val+<+*rhs.pval;+}

template+<typename+_Data,+typename+_Order>
bool+operator+<+(const+value_reference_t<_Data,_Order>&+lhs,+const+value_t<_Data,_Order>&+rhs)+{
++++return+*lhs.pval+<+rhs.val;+}

template+<typename+_Data,+typename+_Order>
void+swap(value_reference_t<_Data,_Order>+lhs,+value_reference_t<_Data,_Order>+rhs)+{
++++std::swap(*lhs.pdata,+*rhs.pdata);
++++std::swap(*lhs.pval,+*rhs.pval);+}


}+//+namespace+sort_helper

}+//+namespace+std|code-block|syntax|javascript|1817909|这是一个使用示例，它根据年龄值对名称和年龄进行排序，使用标准的std：：排序|1817910|char*+Names[]+=+{+"Karl",+"Paul",+"Martin",+"Jennie"+};
int+Age[]+=+{+45,+14,+5,+24+};
typedef+std::sort_helper::value_iterator_t<char*,int>+IndexIt;
std::sort(IndexIt(Names,+Age),+IndexIt(Names%2B4,+Age%2B4));|1817911|排序如下：|1817912|{+"Martin",+"Paul",+"Jennie",+"Karl"+};
{+5,+14,+24,+45+};|1817913|在2017和GCC+5.4.0上测试的代码。|1817914|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

So many asked this question and nobody came up with a satisfactory answer. Here is a std::sort helper that enables to sort two vectors simultaneously, taking into account the values of only one vector. This solution is based on a custom RadomIt (random iterator), and operates directly on the original vector data, without temporary copies, structure rearrangement or additional indices:

<pre><code>namespace std {

namespace sort_helper {

template &lt;typename _Data, typename _Order&gt;
struct value_reference_t;

template &lt;typename _Data, typename _Order&gt;
struct value_t {
 _Data data;
 _Order val;
 inline value_t(_Data _data, _Order _val) : data(_data), val(_val) {}
 inline value_t(const value_reference_t&lt;_Data,_Order&gt;&amp; rhs);
};

template &lt;typename _Data, typename _Order&gt;
struct value_reference_t {
 _Data* pdata;
 _Order* pval;
 value_reference_t(_Data* _itData, _Order* _itVal) : pdata(_itData), pval(_itVal) {}
 inline value_reference_t&amp; operator = (const value_reference_t&amp; rhs) { *pdata = *rhs.pdata; *pval = *rhs.pval; return *this; }
 inline value_reference_t&amp; operator = (const value_t&lt;_Data,_Order&gt;&amp; rhs) { *pdata = rhs.data; *pval = rhs.val; return *this; }
 inline bool operator &lt; (const value_reference_t&amp; rhs) { return *pval &lt; *rhs.pval; }
};

template &lt;typename _Data, typename _Order&gt;
struct value_iterator_t :
 iterator&lt; random_access_iterator_tag, value_t&lt;_Data,_Order&gt;, ptrdiff_t, value_t&lt;_Data,_Order&gt;*, value_reference_t&lt;_Data,_Order&gt; &gt;
{
 _Data* itData;
 _Order* itVal;
 value_iterator_t(_Data* _itData, _Order* _itVal) : itData(_itData), itVal(_itVal) {}
 inline ptrdiff_t operator - (const value_iterator_t&amp; rhs) const { return itVal - rhs.itVal; }
 inline value_iterator_t operator + (ptrdiff_t off) const { return value_iterator_t(itData + off, itVal + off); }
 inline value_iterator_t operator - (ptrdiff_t off) const { return value_iterator_t(itData - off, itVal - off); }
 inline value_iterator_t&amp; operator ++ () { ++itData; ++itVal; return *this; }
 inline value_iterator_t&amp; operator -- () { --itData; --itVal; return *this; }
 inline value_iterator_t operator ++ (int) { return value_iterator_t(itData++, itVal++); }
 inline value_iterator_t operator -- (int) { return value_iterator_t(itData--, itVal--); }
 inline value_t&lt;_Data,_Order&gt; operator * () const { return value_t&lt;_Data,_Order&gt;(*itData, *itVal); }
 inline value_reference_t&lt;_Data,_Order&gt; operator * () { return value_reference_t&lt;_Data,_Order&gt;(itData, itVal); }
 inline bool operator &lt; (const value_iterator_t&amp; rhs) const { return itVal &lt; rhs.itVal; }
 inline bool operator == (const value_iterator_t&amp; rhs) const { return itVal == rhs.itVal; }
 inline bool operator != (const value_iterator_t&amp; rhs) const { return itVal != rhs.itVal; }
};

template &lt;typename _Data, typename _Order&gt;
inline value_t&lt;_Data,_Order&gt;::value_t(const value_reference_t&lt;_Data,_Order&gt;&amp; rhs)
 : data(*rhs.pdata), val(*rhs.pval) {}

template &lt;typename _Data, typename _Order&gt;
bool operator &lt; (const value_t&lt;_Data,_Order&gt;&amp; lhs, const value_reference_t&lt;_Data,_Order&gt;&amp; rhs) {
 return lhs.val &lt; *rhs.pval; }

template &lt;typename _Data, typename _Order&gt;
bool operator &lt; (const value_reference_t&lt;_Data,_Order&gt;&amp; lhs, const value_t&lt;_Data,_Order&gt;&amp; rhs) {
 return *lhs.pval &lt; rhs.val; }

template &lt;typename _Data, typename _Order&gt;
void swap(value_reference_t&lt;_Data,_Order&gt; lhs, value_reference_t&lt;_Data,_Order&gt; rhs) {
 std::swap(*lhs.pdata, *rhs.pdata);
 std::swap(*lhs.pval, *rhs.pval); }


} // namespace sort_helper

} // namespace std
</code></pre>

And this is an usage example that sorts both Names and Age based on Age values, employing standard std::sort:

<pre><code>char* Names[] = { "Karl", "Paul", "Martin", "Jennie" };
int Age[] = { 45, 14, 5, 24 };
typedef std::sort_helper::value_iterator_t&lt;char*,int&gt; IndexIt;
std::sort(IndexIt(Names, Age), IndexIt(Names+4, Age+4));
</code></pre>

sorted to:

<pre><code>{ "Martin", "Paul", "Jennie", "Karl" };
{ 5, 14, 24, 45 };
</code></pre>

Code tested on Visual Studio 2017 and GCC 5.4.0.

blocks|key|937575|text|将姓名和分数合并为单一结构的另一种方法是创建索引列表并对其进行排序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937576|+std::vector<int>+indices(Names.size());
+std::iota(indices.begin(),+indices.end(),+0);
+std::sort(indices.begin(),+indices.end(),
+++++++++++[&](int+A,+int+B)+->+bool+{
++++++++++++++++return+Score[A]+<+Score[B];
++++++++++++});|code-block|syntax|javascript|937577|现在可以使用indices按所需的排序顺序对Names和Scores进行索引。|offset|length|style|CODE|937578|entityMap^0|0|0|6|7|M|5|S|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

An alternative to consolidating the names and scores into a single structure is to create an index list and sort that: 

<pre><code> std::vector&lt;int&gt; indices(Names.size());
 std::iota(indices.begin(), indices.end(), 0);
 std::sort(indices.begin(), indices.end(),
 [&amp;](int A, int B) -&gt; bool {
 return Score[A] &lt; Score[B];
 });
</code></pre>

Now <code>indices</code> can be used to index <code>Names</code> and <code>Scores</code> in the desired sorted order.

The best example I've got is that I want to sort Names based on their Score.

<pre><code>vector &lt;string&gt; Names {"Karl", "Martin", "Paul", "Jennie"};
vector &lt;int&gt; Score{45, 5, 14, 24};
</code></pre>

So if I sort the score to {5, 14, 24, 45}, the names should also be sorted based on their score.

C++, Sort One Vector Based On Another One

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我得到的最好的例子是，我想根据名字的分数对它们进行排序。vector <string> Names {"Karl", "Martin", "Paul", "Jennie"};vector <int> Score{45, 5, 14, 24};因此，如果我将分数排序为{5、14、24、45}，则还应该根据它们的分数对名称...

问C++，基于另一个向量排序
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++，基于另一个向量排序EN