这里有C++STL——全面总结详细教程（附案例解析）（持续更新中）
目录
排序案例
案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序
#include<iostream>
#include<list>
#include<string>
using namespace std;
class Person {
public:
Person(string name, int age, int height) {
this->m_Age = age;
this->m_Height = height;
this->m_Name = name;
}
string m_Name;
int m_Age;
int m_Height;
};
bool ComparePerson(Person &p1, Person &p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height > p2.m_Height;
}
else {
return p1.m_Age < p2.m_Age;
}
}
void test01() {
list<Person>L;
Person p1("张三", 35, 166);
Person p2("李四", 45, 156);
Person p3("王五", 60, 178);
Person p4("张飞", 35, 180);
Person p5("周武", 35, 173);
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
cout << "姓名：" << it->m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
}
cout << "……………………………………" << endl;
L.sort(ComparePerson);
for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
cout << "姓名：" << it->m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
}
}
int main(){
test01();
system("pause");
return 0;
}
我们定义一个bool型的排序规则。
bool ComparePerson(Person &p1, Person &p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height > p2.m_Height;
}
else {
return p1.m_Age < p2.m_Age;
}
}根据题目要求：
如果年龄相同，如果p1的身高大于p2的身高，那么返回真，否则返回假。
扫描二维码关注公众号，回复：
10272051 查看本文章
否则
如果p1的年龄小于p2的身高，那么返回真，否则返回假。
如果题目要求：
按身高升序，按年龄降序呢？
我们只要改一下ComparePerson的规则即可：
bool ComparePerson(Person &p1, Person &p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height < p2.m_Height;
}
else {
return p1.m_Age > p2.m_Age;
}
}看一下运行结果：
按身高升序，按年龄升序呢？
我们只要改一下ComparePerson的规则即可：
bool ComparePerson(Person &p1, Person &p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height < p2.m_Height;
}
else {
return p1.m_Age < p2.m_Age;
}
}运行结果：
总结一下Sort()函数的调用规则：
身高降序“>” 年龄升序“<”
简言之：
升序用“<”小于号
降序用“>”大于号
笼统的概括。主要还是看返回值的。
我们看一下Sort()函数的定义中。比较的个数<2则返回本身，多于两个的数值比较。
{
如有好心人，恳请指教！！！
不知道说的对不对。个人理解：
递归循环。（开始值，最后值，指针，大小）（开始值，中间值，指针，右移一位（大小减半）
然后从中间分成两个list。
对这两个新的list。
继续分成两个。
以此往下。
类似于快速排序吧
}
void sort()
{ // order sequence, using operator<
sort(less<>());
}
template<class _Pr2>
void sort(_Pr2 _Pred)
{ // order sequence, using _Pred
_Sort(begin(), end(), _Pred, this->_Mysize());
}
template<class _Pr2>
iterator _Sort(iterator _First, iterator _Last, _Pr2& _Pred,
size_type _Size)
{ // order [_First, _Last), using _Pred, return new first
// _Size must be distance from _First to _Last
if (_Size < 2)
return (_First); // nothing to do
iterator _Mid = _STD next(_First, static_cast<difference_type>(_Size >> 1));
_First = _Sort(_First, _Mid, _Pred, _Size >> 1);
_Mid = _Sort(_Mid, _Last, _Pred, _Size - (_Size >> 1));
iterator _Newfirst = _First;
for (bool _Initial_loop = true; ; _Initial_loop = false)
{ // [_First, _Mid) and [_Mid, _Last) are sorted and non-empty
if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First))
{ // consume _Mid
if (_Initial_loop)
_Newfirst = _Mid; // update return value
splice(_First, *this, _Mid++);
if (_Mid == _Last)
return (_Newfirst); // exhausted [_Mid, _Last); done
}
else
{ // consume _First
++_First;
if (_First == _Mid)
return (_Newfirst); // exhausted [_First, _Mid); done
}
}
}