实战c++中的vector系列--使用sort算法对vector<unique_ptr<string>>进行排序(sort函数出错“应输入 2 个参数,却提供了 3 个)

之前博客写了对vector使用sort算法进行的排序,之前也写到过vector<unique_ptr<string>>的一些处理方法。

今天就写一下对vector<unique_ptr<string>>使用sort算法进行排序。

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<memory>
bool compare_int(int  &lhs, int  & rhs)
{
    return  lhs > rhs;
}
bool compare_first_letter(const std::unique_ptr<std::string > &lhs, const std::unique_ptr<std::string > & rhs)
{
    return  ((*lhs) < (*rhs));
}

bool compare_unique_ptr_int(  std::unique_ptr<int > &lhs,   std::unique_ptr<int > & rhs)
{
    return  *lhs < *rhs;
}

//bool compare_by_uniqptr(const unique_ptr<int>& a,
//  const unique_ptr<int>& b) {
//  return *a < *b;
//}

int main()
{
    //sort vector<int>
    std::vector<int> int_vector;
    int_vector.push_back(5);
    int_vector.push_back(4);
    int_vector.push_back(3);
    int_vector.push_back(6);
    int_vector.push_back(9);

    for (int i = 0; i < int_vector.size(); i++)
    {
        std::cout << int_vector[i] << " ";
    }
    std::cout << std::endl;

    sort(int_vector.begin(), int_vector.end(), compare_int);
    for (int i = 0; i < int_vector.size(); i++)
    {
        std::cout << (int_vector[i]) << " ";
    }
    std::cout << std::endl;

    // sort vector<unique_ptr<string>>
    std::vector<std::unique_ptr<std::string>> unique_ptr_string_vector;
    std::unique_ptr<std::string> unique_ptr_string(new std::string("adr"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string));

    std::unique_ptr<std::string> unique_ptr_string8(new std::string("abc"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string8));

    std::unique_ptr<std::string> unique_ptr_string7(new std::string("abr"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string7));

    std::unique_ptr<std::string> unique_ptr_string6(new std::string("aar"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string6));

    std::unique_ptr<std::string> unique_ptr_string2(new std::string("ebr"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string2));

    std::unique_ptr<std::string> unique_ptr_string3(new std::string("dbr"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string3));

    std::unique_ptr<std::string> unique_ptr_string4(new std::string("cbr"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string4));

    std::unique_ptr<std::string> unique_ptr_string5(new std::string("bbr"));
    unique_ptr_string_vector.push_back(std::move(unique_ptr_string5));

    for (int i = 0; i < unique_ptr_string_vector.size(); i++)
    {
        std::cout << *(unique_ptr_string_vector[i]) << " ";
    }
    std::cout << std::endl;

    sort(unique_ptr_string_vector.begin(), unique_ptr_string_vector.end(), compare_first_letter);
    for (int i = 0; i < unique_ptr_string_vector.size(); i++)
    {
        std::cout << *(unique_ptr_string_vector[i]) << " ";
    }
    std::cout << std::endl;

    //sort vector<unique_ptr<int>>
    std::vector<std::unique_ptr<int>> v;
    std::unique_ptr<int> unique_ptr_int(new int(5));
    v.push_back(std::move(unique_ptr_int));

    std::unique_ptr<int> unique_ptr_int1(new int(4));
    v.push_back(std::move(unique_ptr_int1));

    std::unique_ptr<int> unique_ptr_int2(new int(3));
    v.push_back(std::move(unique_ptr_int2));

    std::unique_ptr<int> unique_ptr_int3(new int(6));
    v.push_back(std::move(unique_ptr_int3));

    std::unique_ptr<int> unique_ptr_int4(new int(9));
    v.push_back(std::move(unique_ptr_int4));
    for (int i = 0; i < v.size(); i++)
    {
        std::cout << *v[i] << " ";
    }
    std::cout << std::endl;

    //sort(std::make_move_iterator(v.begin()), std::make_move_iterator(v.end()), compare_unique_ptr_int);

    //for (auto i = v.begin(); i != v.end(); i++)
    //{
    //  std::cout << **i << " ";
    //}
    //std::cout << std::endl;

    sort(v.begin(), v.end(), compare_unique_ptr_int);
    for (auto i = v.begin(); i != v.end(); i++)
    {
        std::cout << **i << " ";
    }
    std::cout << std::endl;

    return 0;
}

//输出:
5 4 3 6 9
9 6 5 4 3
adr abc abr aar ebr dbr cbr bbr
aar abc abr adr bbr cbr dbr ebr
5 4 3 6 9
3 4 5 6 9

其实还很简单的,但是对于在类中使用sort算法进行排序,需要注意一些问题。

你很能会遇到这样的错误:

sort函数出错“应输入 2 个参数,却提供了 3 个。

在类中你写了比较函数:

bool compare_unique_ptr_int(  std::unique_ptr<int > &lhs,   std::unique_ptr<int > & rhs)
{
    return  *lhs < *rhs;
}

然后在类的某个成员函数中,使用了sort方法进行排序,第三个参数使用compare_unique_ptr_int函数,这个时候就会出现上面所说的错误。

但是如何改进呢?

方法有两种:

方法一:把compare_unique_ptr_int函数改为静态方法:

static bool compare_unique_ptr_int(  std::unique_ptr<int > &lhs,   std::unique_ptr<int > & rhs)
{
    return  *lhs < *rhs;
}

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

方法二:使用lambda表达式进行

sort(v.begin(), v.end(), [](std::unique_ptr<int > &lhs,   std::unique_ptr<int > & rhs)(){return  *lhs < *rhs;});

这样就大功告成了!!!

时间: 12-21

实战c++中的vector系列--使用sort算法对vector<unique_ptr<string>>进行排序(sort函数出错“应输入 2 个参数,却提供了 3 个)的相关文章

实战c++中的vector系列--再谈vector的insert()方法(都是make_move_iterator惹的祸)

之前说过了关于vector的insert()方法,把vector B的元素插入到vector A中,vector A中的结果我们可想而知,但是vector B中的元素还会如何? 看看之前写过的程序: #include <iostream> #include <vector> int main () { std::vector<int> myvector (3,100); std::vector<int>::iterator it; it = myvector

实战c++中的vector系列--copy set to vector(别混淆了reserve和resize)

stl算法中有个copy函数.我们能够轻松的写出这种代码: #include <iostream> #include <algorithm> #include <vector> using namespace std; int _tmain(int argc, _TCHAR* argv[]) { double darray[10]={1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9}; vector<double> vdoubl

实战c++中的vector系列--将迭代器转换为索引

stl的迭代器非常方便 用于各种算法. 可是一想到vector.我们总是把他当做数组,总喜欢使用下标索引,而不是迭代器. 这里有个问题就是怎样把迭代器转换为索引: #include <vector> typedef std::vector<char *> MYARRAY; // This does the trick inline const int iterator_to_index(MYARRAY &a, MYARRAY::iterator it) { return i

实战c++中的vector系列--C++11对vector成员函数的扩展(cbegin()、cend()、crbegin()、crend()、emplace()、data())

前面提到的emplace_back就是C++11所增加的内容. 所以这篇博客就是想罗列一下C++11对vector容器的扩充. std::vector::cbegin和std::vector::cend 这两个方法是与std::vector::begin和std::vector::end相对应的,从字面就能看出来,多了一个'c',顾名思义就是const的意思. 所以: std::vector::cbegin: Returns a const_iterator pointing to the fi

实战c++中的vector系列--vector&lt;unique_ptr&lt;&gt;&gt;赋值给vector&lt;unique_ptr&lt;&gt;&gt;

之前博客讲到 vector可以使用insert方法,将一个vector copy到另一个vector的后面. 之前的博客也讲到过,如果vector容器内部放的是unique_ptr是需要进行所有权转移的. 现在就来八一八如何vector<unique_ptr<>> insert to vector<unique_ptr<>> 如果常规的vector,我们就可以这么使用insert: // inserting into a vector #include &l

实战c++中的智能指针unique_ptr系列-- unique_ptr的operator=、operator bool、reset、swap、get等介绍

既然打算把unique_ptr写一个系列,就要详尽一点,有些内容也许在vector的时候有个涉及,但是现在还是再谈论一番. 我们要把unique_ptr看做一个类,废话了,它当然是一个类.所以这个类肯定也重载了赋值运算符,即operator=.现在就开始看看operator=在unique_ptr中的使用: 官方描述如下: move assignment (1) unique_ptr& operator= (unique_ptr&& x) noexcept; assign null

实战c++中的智能指针unique_ptr系列-- 使用std::unique_ptr代替new operator(错误:‘unique_ptr’ is not a member of ‘std’)

写了很多篇关于vector的博客,其实vector很便捷,也很简单.但是很多易错的问题都是vector中的元素为智能指针所引起的.所以决定开始写一写关于智能指针的故事,尤其是unique_ptr指针的故事. 这是个开始,就让我们使用std::unique_ptr代替new operator吧! 还是用程序说话: #include<iostream> int main() { while (true) int *x = new int; } 看下任务管理器中的内存: 此时使用智能指针unique

在Node.js中使用RabbitMQ系列二 任务队列

在上一篇文章在Node.js中使用RabbitMQ系列一 Hello world我有使用一个任务队列,不过当时的场景是将消息发送给一个消费者,本篇文章我将讨论有多个消费者的场景. 其实,任务队列最核心解决的问题是避免立即处理那些耗时的任务,也就是避免请求-响应的这种同步模式.取而代之的是我们通过调度算法,让这些耗时的任务之后再执行,也就是采用异步的模式.我们需要将一条消息封装成一个任务,并且将它添加到任务队列里面.后台会运行多个工作进程(worker process),通过调度算法,将队列里的任

我在编写《微软System Center 2012 R2私有云部署实战》中应用的一些小技巧

相信很多同学在处理超大文件,比如几万字.几十万字的文章中,需要图文混排.而图文混排可能会涉及到对图片编号和描述.比如我在<微软System Center 2012 R2私有云部署实战>中,就需要频繁的对章节.图片进行编号.更悲剧的是,有时候写了很多章,一个章节几百张图,需要在某一个位置插一张图,这个时候就需要对后面的图片编号全部重新排列. 这酸爽,干一次绝对不想干第二次.老实说,我在一开始其实也是没把这个当回事的,所以每一字都是自己打出来的,没有在处理word文档的时候 用到一些自动化的手段,