C++ 排序手牌扑克，以找到获胜的手牌

我目前正在为扑克（5张牌）制作一个手动评估器。首先我发牌（不是来自同一副牌），然后我检查每个牌是否有一对，一种三对等，一旦找到匹配的牌，比如说一对a牌，牌的等级将设置为2（1-10，10为最佳），牌的价值也将设置为14（1-14，a最高）

我的问题是尝试对吸盘进行排序，我尝试重载操作符，然后尝试使用sort并生成一个bool func来检查排名。我至少在正确的道路上吗？使用sort实际上似乎并没有对它们进行排序，它只是将它们打印出来hand1、hand2、hand3等，而没有任何检查handrank和value的指示（我使用bool func作为第三个参数）

我已经找了一个小时左右，这是我最后的办法，所以任何帮助都将不胜感激

另外，手牌是一个生成5张牌向量的类，在生成时检查手牌中是否有配对等操作，手牌等级和值是否为私有类成员

谢谢

    bool operator > (const Hand &h1) const
{
    return !((*this) < h1.handRank);
}
bool operator < (const Hand &h1) const
{
    if(handRank < h1.handRank)
    {
       return handRank < h1.handRank;
    }
    if(handRank == h1.handRank)
    {
       return highestValue < h1.highestValue;
    }

}

bool操作符>（const Hand和h1）const
{
返回！（*此）

手在main中创建为hand1、hand2等

每手牌包含5张牌的向量，每张牌有一个值和一套

在每一手牌中，int handrank和int highestvalue（当前获胜手牌中最高牌的值，例如2对包含A和6的牌，A将是最高值）

---

我已经找到了一手牌是双人牌还是同花顺牌等等，我只需要按照获胜的顺序对所有的手牌进行排序，我一直在研究如何一次比较所有的手牌，看看是否有一手牌获胜，或者两手牌是否有皇家同花顺牌。你可能需要自己使用自己的函数来对这些牌进行排序

准备每个函数以查找手牌所需的卡片，从皇家同花顺到一对。然后，逐个迭代每个函数，直到找到匹配的手牌

---

您还需要储存西装，以便能够检测潮水。

这是一个测试工具的片段，该测试工具可交易并获得5张牌手。也许它将帮助您完成您正在尝试的操作

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <tuple>
#include <vector>

enum HandScore
{
    high_card,
    one_pair,
    two_pair,
    three_of_a_kind,
    straight,
    flush,
    full_house,
    four_of_a_kind,
    straight_flush,
    royal_flush,
    num_scores,
};
const char* const HandScoreNames[num_scores] =
{
    "High Card",
    "One Pair",
    "Two Pair",
    "Three of a Kind",
    "Straight",
    "Flush",
    "Full House",
    "Four of a Kind",
    "Straight Flush",
    "Royal Flush",
};
const int kStartingRank = 2;
const int kNumRanks = 13;
const int kNumSuits = 4;
const int kCardsPerHand = 5;
const int kCardsPerDeck = 52;

struct Card
{
    Card(int suit_ = 0, int rank_ = kStartingRank) : rank(rank_), suit(suit_) {}
    bool operator<(const Card& other) const
    {
        return std::tie(rank, suit) < std::tie(other.rank, other.suit);
    }
    int rank;
    int suit;
};

struct Hand
{
    Hand() : cards(kCardsPerHand) {}
    HandScore GetScore()
    {
        HandScore score = high_card;
        std::sort(cards.begin(), cards.end());
        int counts[kNumRanks] = {};
        int suits[kNumSuits] = {};
        for(size_t i = 0; i < cards.size(); ++i)
        {
            ++counts[cards[i].rank - kStartingRank];
            ++suits[cards[i].suit];
        }
        int pair_count = 0;
        int three_count = 0;
        int four_count = 0;
        for(int i = 0; i < kNumRanks; ++i)
        {
            if(counts[i] == 2)
            {
                ++pair_count;
            }
            else if(counts[i] == 3)
            {
                ++three_count;
            }
            else if(counts[i] == 4)
            {
                ++four_count;
            }
        }
        bool is_flush = false;
        for(int i = 0; i < kNumSuits; ++i)
        {
            if(suits[i] == kCardsPerHand)
            {
                is_flush = true;
                break;
            }
        }
        const int spread5  = cards[cards.size() - 1].rank - cards[0].rank;
        const int spread4 = cards[cards.size() - 2].rank - cards[0].rank;
        if(is_flush)
        {
            score = flush;
            if(spread5 == 4)
            {
                if(cards[0].rank == 10)
                {
                    score = royal_flush;
                }
                else
                {
                    score = straight_flush;
                }
            }
            //special check for 2345A
            else if(spread5 == 12 && spread4 == 3 && cards[0].rank == 2 && cards[cards.size() - 1].rank == 14)
            {
                score = straight_flush;
            }
        }
        else
        {
            if(spread5 == 4)
            {
                score = straight;
            }
            //special check for 2345A
            else if(spread5 == 12 && spread4 == 3 && cards[0].rank == 2 && cards[cards.size() - 1].rank == 14)
            {
                score = straight;
            }
            else if(four_count == 1)
            {
                score = four_of_a_kind;
            }
            else if(three_count == 1)
            {
                if(pair_count == 1)
                {
                    score = full_house;
                }
                else
                {
                    score = three_of_a_kind;
                }
            }
            else if(pair_count == 2)
            {
                score = two_pair;
            }
            else if(pair_count == 1)
            {
                score = one_pair;
            }
        }
        return score;
    }
    std::vector<Card> cards;
};

struct Deck
{
    Deck() : cards(kCardsPerDeck)
    {
        for(int s = 0; s < kNumSuits; ++s)
        {
            for(int r = 0; r < kNumRanks; ++r)
            {
                cards[s * kNumRanks + r] = Card(s, r + kStartingRank);
            }
        }
    }
    void shuffle()
    {
        std::random_shuffle(cards.begin(), cards.end());
    }
    void deal(Hand& h)
    {
        for(size_t i = 0; i < h.cards.size(); ++i)
        {
            h.cards[i] = cards[i];
        }
    }
    std::vector<Card> cards;
};

int main()
{
    std::srand(static_cast<unsigned int>(std::time(0)));
    Deck deck;
    Hand hand;
    int scores[num_scores] = {};
    const int num_hands = 1000;
    const int num_width = static_cast<int>(std::log10(num_hands) + 1);
    for(int i = 0; i < num_hands; ++i)
    {
        deck.shuffle();
        deck.deal(hand);
        ++scores[hand.GetScore()];
    }
    std::cout << "Results for " << num_hands << " Hands:" << std::endl;
    for(int i = 0; i < num_scores; ++i)
    {
        std::cout << std::setw(num_width) << std::right << scores[i] << " - " << HandScoreNames[i] << std::endl;
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
枚举内核
{
high_卡，
一对，
两对，
三个一个一个，
直的
脸红
满座，
四个一个一个，
直冲，
罗雅伦，
num_分数，
};
const char*const HandScoreNames[num_分数]=
{
“高牌”，
“一对”，
“两对”，
“三个一类”，
“直”，
“同花顺”，
“满座”，
“四个一类”，
“同花顺”，
“皇家同花顺”，
};
常数int kStartingRank=2；
常数int kNumRanks=13；
常数int kNumSuits=4；
常数int kCardsPerHand=5；
常数int kCardsPerDeck=52；
结构卡
{
卡牌：等级（等级），套装{}
布尔运算符您的代码是什么？您有一个手向量，其中每只手包含一个卡向量？请提供您迄今为止编写的代码。澄清“运算符”的含义。我们如何才能帮助您修复
好的
运算符与相反。它是>=使用
const char*const HandScoreNames
和
HandScore GetScore（）const
GetScore
不是const，因为它修改了
卡片
向量。它可以是const，您只需将其设置为不修改卡片向量：）正如我所说，在这个测试工具中，我的愿望是修改向量。这就是它不是const的原因。我认为您不希望GetScore修改向量，只是这样更容易实现。