C++ 对std:：pair的向量进行排序<；int，std：：唯一性；常数T>&燃气轮机；取决于第一对

我试图对包含常量对象的智能指针的向量对进行排序。我试图仅根据第一个对象进行排序。下面您可以看到（我无数次尝试编写的代码之一）应该可以做到这一点，以及错误的摘录

编译器抱怨lambda参数。我试图使参数常量、非常量、引用、右值引用无效。请帮忙

std::pair<int, std::unique_ptr<const std::string> > a;
auto uniq = std::make_unique<const std::string>("hurz");
a = std::make_pair(1,std::move(uniq));

std::pair<int, std::unique_ptr<const std::string> > b;
uniq = std::make_unique<const std::string>("hurz");
b = std::make_pair(2,std::move(uniq));

std::vector<std::pair<int,std::unique_ptr<const std::string> > > vec;

vec.push_back(std::move(a));
vec.push_back(std::move(b));

std::sort(std::make_move_iterator(vec.begin()),
    std::make_move_iterator(vec.end()),
    []
    (const std::pair<int,std::unique_ptr<const std::string> >& i1,
     const std::pair<int,std::unique_ptr<const std::string> >& i2)
    { return i1.first > i2.first;});

std:：对a；
auto uniq=std:：make_unique（“hurz”）；
a=std:：make_pair（1，std:：move（uniq））；
std：：b对；
uniq=std：：使_独一无二（“hurz”）；
b=std:：make_pair（2，std:：move（uniq））；
std:：vec；
向量推回（标准：：移动（a））；
向量推回（标准：：移动（b））；
std:：sort（std:：make_move_迭代器（vec.begin（）），
std:：make_move_迭代器（vec.end（）），
[]
（常数标准：：对和i1，
const std:：pair&i2）
{返回i1.first>i2.first；}）；

错误消息对我没有帮助：

error: no matching function for call to 
'swap(std::move_iterator<__gnu_cxx::__normal_iterator<std::pair<int, 
std::unique_ptr<const std::basic_string<char> > >*, std::vector<std::pair<int, 
std::unique_ptr<const std::basic_string<char> > > > > >::value_type, 
std::move_iterator<__gnu_cxx::__normal_iterator<std::pair<int, 
std::unique_ptr<const std::basic_string<char> > >*, std::vector<std::pair<int, 
std::unique_ptr<const std::basic_string<char> > > > > >::value_type)' swap(*__a, 
*__b);
candidates are:
 /usr/include/c++/4.9/bits/move.h:166:5: note: void std::swap(_Tp&, _Tp&) 
[with _Tp = std::pair<int, std::unique_ptr<const std::basic_string<char> > >]

plus many more errors in the same vein

错误：没有用于调用的匹配函数
'交换（标准：：移动\迭代器：：值\类型，
std:：move_iterator:：value_type）'swap（*uu a，
*__b） )；
候选人包括：
/usr/include/c++/4.9/bits/move.h:166:5：注意：void std:：swap（_-Tp&，_-Tp&）
[带_-Tp=std:：pair]
再加上许多相同的错误

这里的问题是使用

std:：make\u move\u迭代器。当您这样做时，您将迭代器转换为
move_iterator
，这意味着当您取消引用它们时，您将得到一个
T&
，而不是像普通迭代器那样的
T&

std:：swap
，它在
std:：sort
的实现中使用，它只接受左值引用，因此无法绑定到已解除引用的迭代器。如果你使用

std::sort(vec.begin(),
    vec.end(),
    []
    (const std::pair<int,std::unique_ptr<const std::string> >& i1,
     const std::pair<int,std::unique_ptr<const std::string> >& i2)
    { return i1.first > i2.first;});

std:：sort（vec.begin（），
vec.end（），
[]
（常数标准：：对和i1，
const std:：pair&i2）
{返回i1.first>i2.first；}）；

相反，您将有要绑定的
std:：swap
的左值，并且
std:：swap
将适用于仅移动类型
我对@NathanOliver的答案添加了一些进一步的解释，该答案太长，无法进行注释。我猜OP的想法是使用

std::sort(std::make_move_iterator(vec.begin()), std::make_move_iterator(vec.end()),
    [](const std::pair<int,std::unique_ptr<const std::string> >& i1,
       const std::pair<int,std::unique_ptr<const std::string> >& i2)
       { return i1.first > i2.first;});

std:：sort（std:：make_move_iterator（vec.begin（）），std:：make_move_iterator（vec.end（）），
[]（常数标准：：对和i1，
const std:：pair&i2）
{返回i1.first>i2.first；}）；

i、 例如，将
move\u迭代器应用于
vector.begin（）
，将在排序例程中使用移动分配（而不是副本）。这个想法很吸引人，但它不是必需的，因为在
std:：sort
中，赋值通常是通过
std:：swap
完成的

另一方面，对于使用输入和输出迭代器的算法，如大多数基本上
std:：copy
或
std:：copy\u if
，使用
std:：make\u move\u迭代器可以非常有用。它们通常使用诸如
*output\u it=*input\u it
之类的结构，并与
std:：make\u move\u迭代器一起对应于
*output\u it=std:：move（*input\u it）
，因此，可以使用由
*output\u it
解除引用的类型的移动赋值运算符。
为什么需要
std:：unique\u ptr
而不是简单的
std:：string
？字符串只是一个示例。我有我传递的对象，一旦超出范围，我希望垃圾被收集。“我有我传递的对象…”这是一个指标，你需要一个
std:：shared\u ptr
，而不是
std:：unique\u ptr
。查看他们的所有权概念。我从不同时在两个位置持有对象，而且共享\u ptr在我的应用程序中的性能影响太大。@NathanOliver感谢这两个解决方案，并解释了为什么它不能与移动\u迭代器一起工作！