2

これはやや初歩的な質問かもしれませんが、これが私の問題です。私は 2 つの異なる int 値を持つクラス カードを持っています。このように見えます。

#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

を使用するには2つのオプションがありますstd::sort。operator <1つは、クラスをオーバーロードすることです。

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、その中にcomaprisonロジックを実装しますoperator()。C ++ 11では、これにラムダ関数を使用することもできます。

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 に答える