Question

这可能有点像一个菜鸟问题，但这是我的问题;我有一个带有两个不同int值的类卡，看起来像这样。

#pragma once
class Card
{
public:
int value;
int suite;

Card(int v, int s);
~Card(void);

void printCard();
int getScore();
};

现在我想根据他们的价值排序5张牌。我尝试将它们放入向量中然后使用std :: sort但我无法使它工作。所以我的问题是最好的方法是什么？

Answer 1

您需要重载operator<：

bool operator<(const Card& lhs, const Card& rhs){
.... logic here ... 
}

然后使用std::sort。您可能需要为您的班级设置此操作员朋友。或者在类定义中，您可以实现：

class Card {
 ....
 public:
  bool operator<(const Card& other) const {
  .... logic here...
  }
}; // end of class Card

Answer 2

使用std::sort有两种选择。一个是为您的班级重载operator <：

bool operator< (const Card &lhs, const Card &rhs) {
  return lhs.value < rhs.value;
}

但是，只有在始终比较Card这样的对象时才有意义。如果您只需要将其用于特定排序，则可以使用接受自定义比较器的sort版本。

有多种方法可以定义谓词。对于可重用但简单的标准，可以使用类中的静态函数：

class Card
{
public:
  // ... as before
  static bool lesserValue(const Card &lhs, const Card &rhs) {
    return lhs.value < rhs.value;
  }
};

用法：

std::sort(from, to, &Card::lesserValue);

对于一次性事物（或者对于需要保留内部状态的复杂标准），使用从std::binary_function派生的类并在其operator()中实现comaprison逻辑。在C ++ 11中，您还可以使用lambda函数：

std::sort(from, to, [](const Card &lhs, const Card &rhs) { return lhs.value < rhs.value; });

Answer 3

我想出了这个答案，它使用了比较类，这也使得比较套件非常容易。我还改进了班级中的公共和私人成员，因为有些值不应该是公开的。你的班级目前不需要析构函数。

#include<iostream> 
#include<algorithm> 
#include<vector> 

class Card {

    public:

        Card(int v, int s)
            :
                value(v),
                suite(s)
        {
        }

        /*No need for destructor*/

        int getValue(void) const { return value;}

        int getSuite(void) const { return suite;}

        void printCard(void) const {
            std::cout << "Value = " << value << "\tSuite = " << suite << std::endl;
        }

    private:
        /*these shouldn't be public*/
        int value;
        int suite;
};

class CompareCardValue {

    public:

        bool operator() ( const Card& c1, const Card& c2)
        {
            return c1.getValue() < c2.getValue();
        }
};

class CompareCardSuite{

    public:

        bool operator() ( const Card& c1, const Card& c2)
        {
            return c1.getSuite() < c2.getSuite();
        }
};

int main( ){

    std::vector<Card> deck;
    deck.push_back( Card(2,4) );
    deck.push_back( Card(1,3) );
    deck.push_back( Card(12,3) );
    deck.push_back( Card(8,2) );

    CompareCardSuite comp_suite; //compares for suite
    CompareCardValue comp_value; //compares for value

    /*We would like to use a const iterator since we are
     *not interested in changing the Card intances
     */
    std::vector<Card>::const_iterator it;
    for ( it = deck.begin(); it < deck.end(); it++){
        it->printCard();
    }
    std::cout << std::endl;

    /*sorting on value*/
    std::sort( deck.begin(), deck.end(), comp_value );

    for ( it = deck.begin(); it < deck.end(); it++){
        it->printCard();
    }

    std::cout << std::endl;
    /*sorting on suite*/
    std::sort( deck.begin(), deck.end(), comp_suite );

    for ( it = deck.begin(); it < deck.end(); it++){
        it->printCard();
    }
}

如何使用两个变量对矢量进行排序？

3 个答案: