AI 助理
备案控制台
开发者社区 云原生 容器服务 文章 正文

【转】c++中Vector等STL容器的自定义排序

2017-11-23 1196
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
容器服务 Serverless 版 ACK Serverless，952元额度 多规格
容器服务 Serverless 版 ACK Serverless，317元额度 多规格
容器镜像服务 ACR，镜像仓库100个 不限时长
简介：

如果要自己定义STL容器的元素类最好满足STL容器对元素的要求
    必须要求：
     1、Copy构造函数
     2、赋值=操作符
     3、能够销毁对象的析构函数
    另外：
     1、可用的缺省构造函数，序列型容器必须，用于初始化元素
     2、==操作符定义，用于判断相等
     3、<操作符定义，关联型容器必须，用于缺省排序

 

你可在struct內加入 operator < ,就可以使struct有排序能力.
因為而你的pcd struct內沒有指針,所以不須要有copy constructor
和copy assignment, 編譯器會為你提供的, 你不須要自己做的.
當你要排序時只要寫 sort( obj.begin(), obj.end() )就可.

 

以上内容取自帖子：http://bbs.csdn.net/topics/40228627

另一篇参考地址：http://blog.csdn.net/tigernana/article/details/7293758

以下取自帖子：http://blog.csdn.net/guang11cheng/article/details/7556697

 

三种方式实现vector的自定义排序

方法1：重载运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <vector>
  #include <algorithm>
  #include <functional>
 
using  namespace  std;
struct  TItem
{
     int  m_i32Type;
     int  m_i32ID;
 
     bool  operator  <( const  TItem& rhs)  const  // 升序排序时必须写的函数
     {
         return  m_i32Type < rhs.m_i32Type;
     }
     bool  operator  >( const  TItem& rhs)  const  // 降序排序时必须写的函数
     {
         return  m_i32Type > rhs.m_i32Type;
     }
};
int  main()
{
     vector<TItem> stItemVec;
 
 
     TItem stItem1;
     stItem1.m_i32Type = 1;
     stItem1.m_i32ID = 1;
 
     TItem stItem2;
     stItem2.m_i32Type = 2;
     stItem2.m_i32ID = 2;
 
     TItem stItem3;
     stItem3.m_i32Type = 3;
     stItem3.m_i32ID = 3;
 
     TItem stItem4;
     stItem4.m_i32Type = 2;
     stItem4.m_i32ID = 4;
 
     stItemVec.push_back(stItem1);
     stItemVec.push_back(stItem2);
     stItemVec.push_back(stItem3);
     stItemVec.push_back(stItem4);
 
     // 升序排序
     sort(stItemVec.begin(), stItemVec.end(), less<TItem>());
     // 或者sort(ctn.begin(), ctn.end());   默认情况为升序
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
         printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
 
     printf( "--\n" );
 
     // 降序排序
     sort(stItemVec.begin(), stItemVec.end(), greater<TItem>());
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
         printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
 
     return  0;
}

方法2：全局的比较函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
bool  lessmark( const  TItem& stItem1,  const  TItem& stItem2)
  {
      return  stItem1.m_i32Type < stItem2.m_i32Type;
  }
  
 
bool  greatermark( const  TItem& stItem1,  const  TItem& stItem2)
  {
      return  stItem1.m_i32Type > stItem2.m_i32Type;
  }
  
 
int  main()
  {
      vector<TItem> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(stItem1);
      stItemVec.push_back(stItem2);
      stItemVec.push_back(stItem3);
      stItemVec.push_back(stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), lessmark);  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), greatermark);  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     return  0;
  }

方法3：函数对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
class  CompLess
  {
  public :
      bool  operator  ()( const  TItem& stItem1,  const  TItem& stItem2)
      {
          return  stItem1.m_i32Type < stItem2.m_i32Type;
      }
  };
  
 
class  CompGreater
  {
  public :
      bool  operator  ()( const  TItem& stItem1,  const  TItem& stItem2)
      {
          return  stItem1.m_i32Type > stItem2.m_i32Type;
      }
  };
  
 
int  main()
  {
      vector<TItem> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(stItem1);
      stItemVec.push_back(stItem2);
      stItemVec.push_back(stItem3);
      stItemVec.push_back(stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompLess());  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompGreater());  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
  
 
     return  0;
  }
  
 
/*
  结果如下：
  type: 1, id: 1
  type: 2, id: 2
  type: 2, id: 4
  type: 3, id: 3
  --
  type: 3, id: 3
  type: 2, id: 2
  type: 2, id: 4
  type: 1, id: 1
  可以看出vector的sort的稳定的。
  */

问题：

1，示例代码中只有>和<关系处理，==关系是如何推导出来的？

2，排序时要移动元素，效率怎样？

3，如果自定义结构定义在一个类的内部，使用函数对象进行排序，这个函数对象可以作为类的成员函数吗？

4，在上面的例子中，vector中存放的都是结构（对象）本身，如果存放的是结构指针，该如何排序呢？此时只能通过全局的比较函数或者函数对象来做，且比较函数的参数要是指针类型的，如下：

（1）全局的比较函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
bool  CompLess( const  TItem* pstItem1,  const  TItem* pstItem2)
  {
      return  pstItem1->m_i32Type < pstItem2->m_i32Type;
  }
  
 
bool  CompGreater( const  TItem* pstItem1,  const  TItem* pstItem2)
  {
      return  pstItem1->m_i32Type > pstItem2->m_i32Type;
  }
  
 
int  main()
  {
      vector<TItem*> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(&stItem1);
      stItemVec.push_back(&stItem2);
      stItemVec.push_back(&stItem3);
      stItemVec.push_back(&stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompLess);  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompGreater);  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
     return  0;
  }

　　（2）函数对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <vector>
  #include <algorithm>
  #include <functional>
  
 
using  namespace  std;
  
 
struct  TItem
  {
      int  m_i32Type;
      int  m_i32ID;
  };
  
 
class  CompLess
  {
  public :
      bool  operator  ()( const  TItem* pstItem1,  const  TItem* pstItem2)
      {
          return  pstItem1->m_i32Type < pstItem2->m_i32Type;
      }
  };
  
 
class  CompGreater
  {
  public :
      bool  operator  ()( const  TItem* pstItem1,  const  TItem* pstItem2)
      {
          return  pstItem1->m_i32Type > pstItem2->m_i32Type;
      }
  };
  
 
int  main()
  {
      vector<TItem*> stItemVec;
  
 
     TItem stItem1;
      stItem1.m_i32Type = 1;
      stItem1.m_i32ID = 1;
  
 
     TItem stItem2;
      stItem2.m_i32Type = 2;
      stItem2.m_i32ID = 2;
  
 
     TItem stItem3;
      stItem3.m_i32Type = 3;
      stItem3.m_i32ID = 3;
  
 
     TItem stItem4;
      stItem4.m_i32Type = 2;
      stItem4.m_i32ID = 4;
  
 
     stItemVec.push_back(&stItem1);
      stItemVec.push_back(&stItem2);
      stItemVec.push_back(&stItem3);
      stItemVec.push_back(&stItem4);
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompLess());  //升序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
 
     printf( "--\n" );
  
 
     sort(stItemVec.begin(), stItemVec.end(), CompGreater());  //降序排序
  
 
     for  (size_t i = 0; i < stItemVec.size(); i++)
          printf( "type: %d, id: %d\n" , stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
  
 
     return  0;
  }

　　本文转自编程小翁博客园博客，原文链接：http://www.cnblogs.com/wengzilin/p/3937491.html，如需转载请自行联系原作者

文章标签：
C++
容器
关键词：
C++ vector
C++ stl
C++容器
C++ stl容器
stl容器
文艺小青年
目录
相关文章
白子寰
|
14天前
|
存储 C++ 索引
【C++打怪之路Lv9】-- vector
【C++打怪之路Lv9】-- vector
白子寰
15 1
努力学习的小廉
|
24天前
|
编译器 C++
【C++】—— vector模拟实现
【C++】—— vector模拟实现
努力学习的小廉
31 1
禁默
|
19天前
|
算法 C++ 容器
C++之打造my vector篇（下）
C++之打造my vector篇（下）
禁默
25 0
禁默
|
19天前
|
存储 编译器 C++
C++之打造my vector篇（上）
C++之打造my vector篇（上）
禁默
25 0
以山向海
|
11天前
|
存储 Docker 容器
docker中挂载数据卷到容器
【10月更文挑战第12天】
以山向海
35 5
众所周知
|
4天前
|
存储 Kubernetes C++
Kubernetes VS Docker Swarm：哪个容器编排工具更适合你？
随着容器技术的快速发展，容器编排工具成为了现代软件开发和运维的重要环节。在众多容器编排工具中，Kubernetes和Docker Swarm无疑是最受欢迎的两个。本文将从技术特性、易用性和社区支持三个方面，对Kubernetes和Docker Swarm进行比较，以帮助您选择更适合您需求的容器编排工具。
众所周知
19 3
以山向海
|
5天前
|
存储 缓存 Docker
docker中挂载数据卷到容器
【10月更文挑战第16天】
以山向海
15 2
以山向海
|
7天前
|
存储 关系型数据库 MySQL
使用docker run命令创建容器并挂载数据卷
【10月更文挑战第14天】
以山向海
20 1
以山向海
|
8天前
|
存储 Docker 容器
docker中挂载数据卷到容器
【10月更文挑战第13天】
以山向海
15 2
叮叮当当就是我
|
9天前
|
运维 监控 数据可视化
Docker容器可视化管理工具 - WGCLOUD基础介绍
WGCLOUD是新一代运维监测平台，它可以监控Docker容器的各种性能数据，比如内存，cpu，Image，运行时间，运行状态，端口映射等信息
叮叮当当就是我
32 2
云原生

容器服务

热门文章

最新文章

  • 1
    Docker 镜像加速器
  • 2
    Docker CE 镜像源站
  • 3
    Minikube - Kubernetes本地实验环境
  • 4
    Docker的Windows容器初体验
  • 5
    Docker学习路线图 (持续更新中)
  • 6
    利用Zipkin对Spring Cloud应用进行服务追踪分析
  • 7
    基于Docker容器的，Jenkins、GitLab构建持续集成CI
  • 8
    谈谈 Docker Volume 之权限管理（一）
  • 9
    容器镜像服务 Docker镜像的基本使用
  • 10
    使用阿里云容器服务Jenkins 2.0实现持续集成之Pipeline篇(updated on 2016.12.23)
  • 1
    基于Docker安装Grafana和Prometheus
    17
  • 2
    JVM进阶调优系列(7)JVM调优监控必备命令、工具集合|实用干货
    26
  • 3
    前端的全栈之路Meteor篇（一）：开发环境的搭建 -全局安装或使用容器镜像
    42
  • 4
    前端的全栈之路Meteor篇（二）：容器化开发环境下的meteor工程架构解析
    29
  • 5
    拿下奇怪的前端报错（五）：SyntaxError: Unexpected token ‘??=‘或‘xxx‘ - 基于容器搭建开发环境或许是更好的选择
    263
  • 6
    容器内的Nodejs应用如何获取宿主机的基础信息-系统、内存、cpu、启动时间，以及一个df -h的坑
    34
  • 7
    拿下奇怪的前端报错（三）：npm install卡住了一个钟- 从原理搞定安装的全链路问题
    111
  • 8
    拿下奇怪的前端报错（二）：nvm不可用报错`GLIBC_2.27‘‘GLIBCXX_3.4.20‘not Found？+ 使用docker构建多个前端项目实践
    30
  • 9
    JVM进阶调优系列(3)堆内存的对象什么时候被回收?
    26
  • 10
    使用WASM插件扩展ASM中监控指标的维度信息
    93

    • 相关课程

    更多
  • 云计算、容器和云原生基础课程
  • Serverless 容器从入门到精通: - Serverless Kubernetes
  • 容器安全与Palo Alto Networks解决方案
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • 使用阿里云容器服务和容器网络文件系统搭建WordPress网站
  • 容器镜像管理命令
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型
  • 容器的启动和操作
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月