小さなC++ゲームのヘルプ

Question

私は端末で動作するソリティアのゲームを書いています。現在のところ、プログラムはコンパイルされ、実行され、4つの列に配置された4つのカードをプレーヤに与え、さらに多くのカードを0にして列に追加します。列が大きくなると、出力はベクトル（実際はベクトルのベクトル）に配置されます。

理想的には、必要に応じてカードをさらに集めた後、プレイヤーは1〜4の数字を入力して、他のカードと比較したい列を選択します。次に、その列の一番上のカードと他の一番上のカードを比較して、それが削除できるかどうかを確認する必要があります。これは私が問題を抱えている部分です。まず、ベクトルのベクトルに正しくカードを入力しているかどうかはわかりません。どうすればそれらを互いに比較するかわかりません。私は次のようなものを使用しようとしました：

column[2].back().getSuit() 2列の最上位カードのスーツにアクセスして数値を与え、もう一方のスーツと比較します。 私はカードのランクを比較するのに似たようなことをしましたが、私は運がないです。

誰かが自分のコードを使って私に例を示すことはできますか？ 各列のトップカードのスーツとランクを適切に比較するにはどうすればよいですか？ここで

は、これまでの私のコードです：

#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のための比較演算子の追加

試してみてください。今、あなたがする必要があります

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

：これが機能する

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

を、あなたはconstとgetRankとgetSuitメソッドをマークする必要があります2つの列の「上」にあるものを含めて、2つのカードを単純に比較することができます。例：

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

ベクトルが空の場合、backは機能しません。

Answer 2

私は私が列挙型に追加するだけの場合には、私は列挙型を維持したいすべてと一緒に文字列を返す関数の

まず物事のカップルを示唆して思ったので、あなたが提案を求めたのHia、後であなたが、その後少し明確にすることができsuits::spade、suits::get_string(suits::spade)などを参照してください

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 
    } 
}; 

（admitadlyこの場合はそう）。

私はその後、あなたはここで比較を行うことができ、自分のクラスでスーツと番号を持っているでしょう：

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; 
    } 
}; 

最後に utstream演算子は（私もCardSuitクラスに似た順位クラスになるだろう

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; 
} 

のようなもので、それぞれ偽と真

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; 

戻り

ように - します場合はそれも奇妙です）。