帮助小型C ++游戏

Question

I'm writing a game of solitaire that runs in the terminal. As of now, the program compiles and runs and gives the player four cards, placed in four columns and allows them to press 0 for more cards, which are added onto the columns. As the column grows, it's output should be placed in a vector (actually, a vector of vectors).

Ideally, after gathering more cards if necessary, the player inputs a number ranging from 1-4 to select the column they'd like to compare to the others. It should then compare the top card of that column to the other top cards and see if one can be deleted. This is the part that I'm having trouble with. First of all, I'm not sure if I'm inputing the cards correctly into the vector of vectors and I'm not sure how to compare them to each other. I've tried using something like:

column[2].back().getSuit() to acces the suit of the top card of column two, then giving it a numerical value and comparing it to the suit of the other. I did a similar thing to compare the ranks of the cards but I'm not having any luck.

Can anyone show me an example using my or your own code? How should I properly compare the suit and rank of the top cards in each column?

Here is my code so far:

#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();
            }

            }



}

Any suggestions, pointers, tips, are great, thanks.

Answer 1

You don't need to translate the suit to a numeric value for comparison. You can compare the enumerated types directly.

Try adding a comparison operator for Card s:

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

For this to work, you'll have to mark the getRank and getSuit methods with const :

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

Now you should be able to simply compare any two cards, including those on "top" of two columns. For example:

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

Note that back won't work if the vector is empty.

Answer 2

Hia, you asked for suggestions so I thought I suggest a couple of things

First of all I like to keep enumerated types and the function that returns a string together, just in case I add to the enumerated type later (unlikely in this case 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
  }
};

You then refer to suits::spade , suits::get_string(suits::spade) etc which can be a bit clearer.

I would then have the suit and the number in their own classes, then you can do the comparison here:

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

Then

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

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

returns true

You can then inherit from the CardSuit class like so

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

so that

  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;

returns false and true respectively

Finally utstream operator is something like

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

(I would also make a rank class similar to the CardSuit class - in which case it is even tidier).