1

我陷入了一个问题。这是我的代码。我有class Card和class deckOfCards。我的问题在于函数straight和sortFunc. 我想对我在main调用中创建的向量进行排序fiveHand。我看到了很多例子，但就我而言，我不明白如何正确地做到这一点。

我有类似的错误i并且j没有被声明：

#include <iostream>

using namespace std;


class Card
{
    private:
        int m_suit;
        int m_face;
    public:
        Card(int face, int suit);
        static string suits[];
        static string faces[];
        static string toString(string s_face, string s_suit);
        int getFace();
        void setFace(int face);
        int getSuit();
        void setSuit(int suit);
};

Card::Card(int face, int suit)
{
    m_face = face;
    m_suit = suit;
} 
string Card::faces[] = {"Ace", "Deuce", "Three", "Four", "Five", 
"Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"};

string Card::suits[] = {"hearts", "diamonds", "clubs", "spades"};

int Card::getFace(){return m_face;}
void Card::setFace(int face){m_face = face;}
int Card::getSuit(){return m_suit;}
void Card::setSuit(int suit){m_suit = suit;}

string Card::toString(string s_face, string s_suit)
{
    string card = s_face + "\tof\t " + s_suit;
    return card;
}




#include <iostream>     // cout
#include <algorithm>    // random_shuffle
#include <vector>       // vector
#include <ctime>        // time
#include <cstdlib> 
#include "Card.h"

using namespace std;

class deckOfCards
{
    private:
        vector<Card> deck;

    public:
        deckOfCards();
        static int count;
        static int next;
        vector<Card>& getDeck() {return deck;}
        void shuffle(vector<Card>& deck);
        Card dealCard();
        bool moreCards();
        void pairs(vector<Card>& fiveHand);
        void threeOfKind(vector<Card>& fiveHand);
        void fourOfKind(vector<Card>& fiveHand);
        void flush(vector<Card>& fiveHand);
        void straight(vector<Card>& fiveHand);
        bool sortFunc(vector<Card>&  fiveHand[i], vector<Card>&  fiveHand[j]);

};

int deckOfCards::count = 0;
int deckOfCards::next = 0;

deckOfCards::deckOfCards()
{
    const int FACES = 13;
    const int SUITS = 4;
    for (int suit = 0; suit < SUITS; suit++)
        {
            for (int face = 0; face < FACES; face++)
                {
                    Card card = Card(face, suit); //card created and initialized
                    deck.push_back(card);
                }
        }

}

void deckOfCards::shuffle(vector<Card>& deck)
{
    srand(static_cast<unsigned int>(time(0)));  
    random_shuffle(deck.begin(), deck.end());
}

Card deckOfCards::dealCard()
{
    Card nextCard = deck[next];
    next++;
    return nextCard;
}

bool deckOfCards::moreCards()
{
    const int FIVE_CARD = 5;
    if (count < FIVE_CARD)
    {
        count++;
        return true;
    }
    else
        return false;
}

void deckOfCards::pairs(vector<Card>& fiveHand)
{
    int pair = 0;
    const int MAX_CARDS = 5;
    for (int i = 0; i < MAX_CARDS; i++)
    {
        int j = i+1;
        for (j; j < MAX_CARDS; j++)
        {
            if (fiveHand[i].getFace() == fiveHand[j].getFace())
                pair++;
        }
    }
    if (pair == 1)
    {
        cout << "You have one pair!" << endl;
    }
    else if (pair == 2)
    {
        cout << "You have two pairs!" << endl;
    }
}


void deckOfCards::threeOfKind(vector<Card>& fiveHand)
{
    if (((fiveHand[0].getFace() == fiveHand[1].getFace())&&(fiveHand[1].getFace() == fiveHand[2].getFace()))
        ||((fiveHand[1].getFace() == fiveHand[2].getFace())&&(fiveHand[2].getFace() == fiveHand[3].getFace()))
        ||((fiveHand[2].getFace() == fiveHand[3].getFace())&&(fiveHand[3].getFace() == fiveHand[4].getFace())))
        {
            cout << "Your hand contains three cards of the same faces!" << endl;
        }

}

void deckOfCards::fourOfKind(vector<Card>& fiveHand)
{
    if (((fiveHand[0].getFace() == fiveHand[1].getFace())
        &&(fiveHand[1].getFace()== fiveHand[2].getFace())
        &&(fiveHand[2].getFace()== fiveHand[3].getFace()))
        ||((fiveHand[1].getFace() == fiveHand[2].getFace())
        &&(fiveHand[2].getFace() == fiveHand[3].getFace())
        &&(fiveHand[3].getFace() == fiveHand[4].getFace())))
    {
        cout << "Your hand contains four cards of the same faces!" << endl;
    }   
}

void deckOfCards::flush(vector<Card>& fiveHand)
{
    if ((fiveHand[0].getSuit() == fiveHand[1].getSuit())
        &&(fiveHand[1].getSuit() == fiveHand[2].getSuit())
        &&(fiveHand[2].getSuit() == fiveHand[3].getSuit())
        &&(fiveHand[3].getSuit() == fiveHand[4].getSuit()))
        {
            cout << "Congradulations!!! You have a flush!!!" << endl;
        }   
}

void deckOfCards::straight(vector<Card>& fiveHand)
{
    //sort cards based on faces
    sort(fiveHand.begin(), fiveHand.end(), sortFunc(vector<Card>&  fiveHand[i], vector<Card>&  fiveHand[j])); 
    if ((fiveHand[1].getFace() == (fiveHand[0].getFace()+1))
        &&(fiveHand[2].getFace() == (fiveHand[1].getFace()+1))
        &&(fiveHand[3].getFace() == (fiveHand[2].getFace()+1))
        &&(fiveHand[4].getFace() == (fiveHand[3].getFace()+1)))
        {
            cout << "You're so lucky!!! You have a straight!" << endl;
        }
}

bool deckOfCards::sortFunc(vector<Card>&  fiveHand[i], vector<Card>&  fiveHand[j])
{
    if (fiveHand[i].getFace() < fiveHand[j].getFace())
        return true;
    else
        return false;
}



#include "deckOfCards.h"


using namespace std;

int main(int argc, char** argv) 
{
    deckOfCards cardDeck; // create DeckOfCards object
    vector<Card> fiveHand;
    cardDeck.shuffle(cardDeck.getDeck()); // shuffle the cards in the deck

    cout << "Your cards are: \n" << endl;
    while (cardDeck.moreCards() == true)
    {
        Card currCard = cardDeck.dealCard();
        fiveHand.push_back(currCard);
        string face = Card::faces[currCard.getFace()];
        string suit = Card::suits[currCard.getSuit()];
        string card = Card::toString(face,suit);
        cout << card << endl;
    }
    cout << endl;
    cardDeck.pairs(fiveHand);
    cardDeck.threeOfKind(fiveHand);
    cardDeck.fourOfKind(fiveHand);
    cardDeck.flush(fiveHand);
    cardDeck.straight(fiveHand);

    return 0;
}
4

3 回答 3

1

要添加到 Ben 的答案，除了他提出的更改之外，您还需要进行Card::getFace并且可能是Card::getSuitconst 方法。否则，您不能const Card在 that 中的 like实例上调用这些方法sortFunc。

int Card::getFace() const { return m_face; }
int Card::getSuit() const { return m_suit; }

请注意，您可以选择sortFunc像 Ben 的想法一样创建一个自由函数，也可以在内部将其设为静态函数deckOfCards：

class deckOfCards
{
public:
    // ...
    static bool sortFunc(const Card &lhs, const Card &rhs);
};

这可能会在sortFunc旨在与class deckOfCards.

最后，您应该进行修改sortFunc，使其进行稳定的比较：

bool deckOfCards::sortFunc(const Card &lhs, const Card &rhs)
{
  return !(rhs.getFace() < lhs.getFace());
}

调用std::sort将如下所示：

std::sort(fiveHand.begin(), fiveHand.end(), deckOfCards::sortFunc);
于 2013-11-13T02:29:40.130 回答
1

sortFunc()被宣布错误，你有：

 bool deckOfCards::sortFunc(vector<Card>&  fiveHand[i], vector<Card>&  fiveHand[j])

在未声明i和的地方j，正确的函数声明应该是：

 //if you want to call sortFunc like sortFunc(deck[0], deck[1])
 bool deckOfCards::sortFunc(Card& first, Card& second)
 //if you want to call sortFunc like sortFunc(deck0, deck1), then
 bool deckOfCards::sortFunc(vector<Card>& first, vector<Card>& second)

如果要std::sort vector<Card>s，最好重载<运算符：

friend bool operator<(const Card &first, const Card &second); //to Card class
bool operator<(const Card &first, const Card &second)
{
    if (first.getFace() < second.getFace())
        return true;
    return false;
}
于 2013-11-13T02:15:55.757 回答
0

部分问题似乎是sortFunc需要两个向量，而您正试图使用​​它对单个向量进行排序。它应该这样定义：

bool sortFunc(const Card &first, const Card &second)
{
    if (first.getFace() < second.getFace())
        return true;
    else
        return false;
}

第二个问题：您的呼叫sort不正确。将函数sortFunc作为参数传递时，不包括括号或参数。您只需将函数名称视为变量名称，如下所示：

sort(fiveHand.begin(), fiveHand.end(), sortFunc);

另外，请注意，我已将其定义sortFunc为独立函数而不是成员函数。如果您尝试使用我上面显示的sortFunc作为成员函数的调用，它将不起作用，因为如果没有该类型sort的对象并且没有deckOfCards可以使用的对象，您将无法调用成员函数。

于 2013-11-13T02:21:48.413 回答