小C++游戏帮助

Question

我正在写一个在终端中运行的纸牌游戏。截至目前，该程序编译并运行，给玩家四张牌，分为四列，并允许他们按0来获取更多牌，并将其添加到列中。随着列的增长，它的输出应该放置在一个向量中（实际上是向量的向量）。

理想情况下，如果需要收集更多卡片，玩家将输入一个范围为1-4的数字，以选择他们想要与其他人比较的列。然后它应该将该列的顶部牌与其他顶牌进行比较，看看是否可以删除。这是我遇到麻烦的部分。首先，我不确定是否将卡片正确输入矢量矢量中，而我不知道如何将它们相互比较。我尝试使用类似的东西：

column[2].back().getSuit()访问第二列的顶部卡的诉讼，然后给它一个数值，并将其与其他的诉讼进行比较。 我做了类似的事情来比较卡的排名，但我没有任何运气。

任何人都可以使用我或你自己的代码给我看一个例子吗？ 我应该如何正确比较每列中顶级牌的花色和等级？

这是到目前为止我的代码：

#include <iostream> 
#include <algorithm> 
#include <vector> 
#include <cstdlib> 
#include <ctime> 

using namespace std; 

enum suits 
{ 
    diamond, club, heart, spade 
}; 

class Card 
{ 
private: 
    int rank; 
    suits suit; 
public: 
    Card(); 
    Card(suits, int); 
    int getRank() { return rank; } 
    suits getSuit() { return suit; } 
    void setRank(int rankvalue) { rank = rankvalue; } 
    void setSuit(suits suitvalue) { suit = suitvalue; } 
}; 

ostream & operator<<(ostream &, Card); 

Card::Card() 
{ 
    rank = 1; 
    suit = spade; 
} 

Card::Card(suits suitvalue, int rankvalue) 
{ 
    rank = rankvalue; 
    suit = suitvalue; 
} 

ostream & operator<<(ostream & out, Card aCard) 
{ 
    switch (int rank = aCard.getRank()) 
    { 
     case 14: out << "Ace"; break; 
     case 11: out << "Jack"; break; 
     case 12: out << "Queen"; break; 
     case 13: out << "King"; break; 
     default: out << rank; 
    } 

    switch (suits suit = aCard.getSuit()) 
    { 
     case diamond: out << " of Diamonds"; break; 
     case spade: out << " of Spades"; break; 
     case heart: out << " of Hearts"; break; 
     case club: out << " of Clubs"; break; 
    } 

    return out; 
} 

class RandomInteger 
{ 
public: 
    RandomInteger(); 
    unsigned int operator() (unsigned int max); 
}; 

RandomInteger::RandomInteger() 
{ 
    srand(time(0)); 
} 

unsigned int RandomInteger::operator()(unsigned int max) 

{ 
    unsigned int rval = rand(); 
    return rval % max; 
} 

RandomInteger randomizer; 

class Deck 
{ 
    Card cards[52]; 
    int topCard; 
public: 
    Deck(); 
    void shuffle(); 
    bool isEmpty() { return topCard <= 0; } 
    Card draw(); 
}; 

extern RandomInteger randomizer; 

Deck::Deck() 
{ 
    topCard = 0; 
    for (int i = 1; i <= 13; i++) 
    { 
     Card c1(diamond, i), c2(spade, i), c3(heart, i), c4(club, i); 
     cards[topCard++] = c1; 
     cards[topCard++] = c2; 
     cards[topCard++] = c3; 
     cards[topCard++] = c4; 
    } 
} 

Card Deck::draw() 
{ 
    if (!isEmpty()) 
     return cards[--topCard]; 
    else 
    { 
     Card spadeAce(spade, 1); 
     return spadeAce; 
    } 
} 

void Deck::shuffle() 
{ 
    random_shuffle(cards, cards+52, randomizer); 
} 

class Player 
{ 
public: 
    Player(); 
    void print(); 
    Card draw(Deck &); 
    typedef vector<Card> cards; 
    vector<cards> column; 
}; 

//ostream & operator<<(ostream &, Player&); 

Player::Player() 
{ 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
    column.push_back(vector<Card>()); 
} 

Card Player::draw(Deck & aDeck) 
{ 
    for (int i = 0; i < 4; i++) 
     column[i].push_back(aDeck.draw()); 
} 

void Player::print() 
{ 
    cout << "Col 1 \t\t Col 2 \t\t Col 3 \t\t Col 4 \n"; 
    bool more = true; 
    for (int j = 0; more; j++) 
    { 
     more = false; 
     for (int i = 0; i < 4; i++) 
      if (j < column[i].size()) 
     { 
     cout << column[i][j] << "\t"; 
     more = true; 
     } 
      else 
      cout << "\t\t"; 
    cout << endl; 
    } 
} 

int main() 
{ 
    Deck deck; 
    deck.shuffle(); 

    Player player; 
    player.draw(deck); 
    //while (!deck.isEmpty()) 
    //{ 
    cout << "Enter a column number (0 to draw four new cards): " << endl; 
    //} 
    player.print(); 

    int input; 
    int i; 
    vector<vector<Card> > columns(4); 
    while (cin >> input) 
    if (input == 0) 
    { 
     player.draw(deck); 
     player.print(); 
     columns.push_back(vector<Card>()); 
     columns.push_back(vector<Card>()); 
    columns.push_back(vector<Card>()); 
     columns.push_back(vector<Card>()); 
    } 
     else while (cin >> input) 
      if (input == 1) 
      { 
      for (i = 0; i > 4; i++) 
       { 
         columns.push_back(vector<Card>()); 
      } 
      for (i = 0; i > 4; i++) 
        { 
        columns[0].back().getSuit(); 
       columns[1].back().getSuit(); 
       columns[2].back().getSuit(); 
       columns[3].back().getSuit(); 
      } 

      } 



} 

任何建议，三分球，技巧，是伟大的，谢谢。

Answer 1

您不需要将套装翻译成数值进行比较。您可以直接比较枚举类型。

尝试添加比较运算符Card S：

bool operator==(const Card& a, const Card& b) { 
    return a.getRank() == b.getRank() && a.getSuit() == b.getSuit(); 
} 

对于这个工作，你必须标记getRank和getSuit方法与const：

int getRank() const { return rank; } 
suits getSuit() const { return suit; } 

现在你应该能够简单地比较任意两张卡片，包括两列“顶部”的卡片。例如：

if (columns[1].back() == columns[2].back()) { ... } 

请注意，如果向量为空，back将不起作用。

Answer 2

Hia的，你自找的建议，所以我想我建议两件事

所有我喜欢让枚举类型的第一和一起返回一个字符串，以防万一我添加到枚举类型的功能后来（在这种情况下admitadly不太可能）

class suits{ 
public: 
    enum type{ 
    diamond, club, heart, spade, 
    }; 

    static 
    std::string get_string(const type& t) 
    { 
    switch (t) { 
    case diamond: return"Diamonds"; 
    case spade: return"Spades"; 
    case heart: return"Hearts"; 
    case club: return"Clubs"; 
    } 
    throw("invalid suit"); //this is a bit ugly - but you get the idea 
    } 
}; 

然后，您可以参考suits::spade，suits::get_string(suits::spade)等，这可有点清晰。

那么我将有西装，在自己的班级数，那么你可以在这里做了比较：

class CardSuit 
{ 
private: 
    suits::type m_suit; 
protected: 
    std::string get_string() const {return suits::get_string(m_suit);} 
public: 
    CardSuit(const suits::type& t) : m_suit(t) {} 
    void setSuit(const suits::type& t) { m_suit = t;} 
    const suits::type& getSuit() const {return m_suit;} 
    bool operator<(CardSuit cs) 
    { 
    return m_suit<cs.getSuit(); //You must have the enum in the suit order 
    } 
}; 

然后

CardSuit club(suits::club); 
    CardSuit spade(suits::spade); 

    if (club<spade) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

返回true

然后，您可以从CardSuit类继承，像这样

class Card : public CardSuit 
{ 
private: 
    int rank; 
public: 
    Card(); 
    Card(suits::type, int); 
    int getRank() { return rank; } 
    void setRank(int rankvalue) { rank = rankvalue; } 
    std::string get_suit() const {return CardSuit::get_string();} 

bool operator<(const Card& c) 
    { 
    if (CardSuit::operator<(c)) 
     return true; 
    if (rank<c.getRank()) 
     return true; 
    else return false; 
    } 
}; 

使

Card c1(suits::club, 4); 
    Card c2(suits::club, 5); 
    Card c3(suits::diamond, 5); 

    if (c2<c1) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

    if (c3<c1) 
    std::cout<<"true"<<std::endl; 
    else 
    std::cout<<"false"<<std::endl; 

回报虚实分别

最后 utstream操作是一样的东西

ostream & operator<<(ostream & out, Card aCard) 
{ 
    switch (int rank = aCard.getRank()) 
    { 
    case 14: out << "Ace"; break; 
    case 11: out << "Jack"; break; 
    case 12: out << "Queen"; break; 
    case 13: out << "King"; break; 
    default: out << rank; 
    } 

    out << " of "<< aCard.get_suit(); 

    return out; 
} 

（我也做出类似的CardSuit类排名等级 - 中它甚至更加整洁）。