C++ C++；如何进行2排序并将结果合并为1

父类：

Character

子类：

Elf
Human

我有一个变量是

int myScore;
string myType;

所以我做的是按我的类型排序，然后按分数升序排序

就是说如果我有这样的记录

[1] Human, 99
[2] Elf, 91
[3] Elf, 99
[4] Human, 99

如果可以的话

[1] Human, 90 
[2] Human, 99
[3] Elf, 91
[4] Elf, 99

我以前听过merge函数，它可以将2个排序合并为1个排序

但是我如何使用它呢

我现在所做的是

在character.cpp

struct sort_by_score
{
    static bool operator()(Character* x, Character* y)
    {
        return x->getScore() < y->getScore();
    }
};

struct按分数排序
{
静态布尔运算符（）（字符*x，字符*y）
{
返回x->getScore（）getScore（）；
}
};

在main.cpp

是我干的

int main()
{
Character *chara[100];
vector<Character*> sortVector;

//some input of value here.. assuming now got 4 pointers to object, 2 human 2 elf. 

sortVector.clear();
sortVector.assign(chara,chara + characterCounter);

//here i got question on how to sort by Human Then Elf

//2nd sort is sort by score
sort(sortVector.begin(), sortVector.end(), sort_by_score());

for (int i=0;i<characterCounter;i++)
{
cout << sortVector.toDisplay() << endl;
}

return 0;
}

intmain（）
{
字符*字符[100]；
向量分类向量；
//这里有一些输入值..假设现在有4个指向对象的指针，2个人类2个精灵。
sortVector.clear（）；
sortVector.assign（字符，字符+字符计数器）；
//在这里，我有一个问题，关于如何按人类和精灵排序
//第二种排序是按分数排序
排序（sortVector.begin（）、sortVector.end（）、按分数排序（））；
对于（inti=0；i，您也可以使用lambdas（C++0x/11）非常简单地执行此操作：

向量v=。。。；
排序（v.begin（），v.end（），[]（常量字符和lhs，常量字符和hs）{
返回lhs.getType（）==rhs.getType（）？lhs.getScore（）

或者对于指针：

vector<Character*> v = ...;

sort(v.begin(), v.end(), [](const Character *lhs,const Character * hs){
    return lhs->getType() == rhs.getType() ? lhs->getScore() < rhs->getScore()
                                           : lhs->getType() < lhs->getType();
});

向量v=。。。； 排序（v.begin（），v.end（），[]（常量字符*lhs，常量字符*hs）{ 返回lhs->getType（）==rhs.getType（）？lhs->getScore（）getScore（） ：lhs->getType（）getType（）； });

---

我找不到“标准组合器”，所以我自己写了一个。这应该可以：

template<class T, class First, class Second>
class combine {
    First first;
    Second second;
public:
    bool operator()(const T & lhs, const T & rhs) const {
        if(first(lhs, rhs)) return true;
        if(first(rhs, lhs)) return false;
        return second(lhs, rhs);
    }
};

模板
分级联合收割机{
首先；
第二；
公众：
布尔运算符（）（常数T&lhs、常数T&rhs）常数{
if（第一个（左、右）返回true；
if（第一个（右、左）返回false；
返回秒（左、右）；
}
};

具有两个基本比较函子

struct less_type
{
    static bool operator()(const Character & lhs, const Character & rhs) {
        return lhs.getType() < rhs.getType();
    }
};
struct less_score
{
    static bool operator()(const Character & lhs, const Character & rhs) {
        return lhs.getScore() < rhs.getScore();
    }
};

struct-less\u类型
{
静态布尔运算符（）（常量字符和lhs、常量字符和rhs）{
返回lhs.getType（）

可按如下方式使用：

vector<Character*> v = ...;

sort(v.begin(),v.end(), combine<Character,less_type,less_score>());

向量v=。。。； 排序（v.begin（）、v.end（）、combine（））；

---

这在不支持C++0x lambdas的情况下也可以工作。

为什么使用指针而不是引用？现在向量的类型是什么？我在您的描述中看到

字符

，在

运算符的实现中看到了
形状
。关于形状和字符，但是如何使用<代码>运算符（）（Shape*，Shape*）？

还是字符继承自Shape？

vector<Character*> v = ...;

sort(v.begin(),v.end(), combine<Character,less_type,less_score>());