2

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

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

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

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

现在我想按价值对 5 张卡片进行排序。我尝试将它们放入向量中，然后使用 std::sort 但我无法让它工作。所以我的问题是最好的方法是什么？

4

3 回答 3

3

您将需要重载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
于 2013-02-19T15:32:09.263 回答
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(). 在 C++11 中，您还可以为此使用 lambda 函数：

std::sort(from, to, [](const Card &lhs, const Card &rhs) { return lhs.value < rhs.value; });
于 2013-02-19T15:41:09.767 回答
0

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

#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();
    }
}
于 2013-02-19T16:31:40.663 回答