class Card {

  friend ostream &operator<<(ostream &out, const Card &c);

  public:
    Card(char suit, string value);
    Card(int suit, int value);
    void setSuit(char suit);
    void setValue(string value);
    void setNext(Card *next);
    char getSuit();
    string getValue();
    int getBlackJackValue();
    Card *getNext();

    static const int suits = 4;
    static const int values = 13;

  private:
    char suit;
    string value;
    Card *next;

    char intToSuit(int suit) const;
    string intToValue(int value) const;

}; // Card class

/*------------------------------------------------------------------------*/

Card::Card(char suit, string value) - constructor to initialize an
  object.

Card::Card(int suit, int value) - constructor to initialize an object,
  but for ints representing the card suit and value.

void Card::setSuit(char suit) - accessor method

void Card::setValue(string value) - accessor method

void Card::setNext(Card *next) - accessor method

char Card::getSuit() - observer method

string Card::getValue() - observer method

int Card::getBlackJackValue() - observer method, but one that returns
  the card's value in the game of Black Jack.

Card *Card::getNext() - observer method

char Card::intToSuit(int suit) - For the given int, returns a char
  representing the proper suit.

string Card::intToValue(int value) - For the given int, returns a
  string representing the proper card value.

ostream &operator<<(ostream &out, const Card &c) - inserts a card
  object into the stream in the form <value><suit> (e.g., 10D, AH).

/*========================================================================*/

class Hand
{

  friend ostream &operator<<(ostream &out, const Hand &h);

  public:
    Hand(Card *cards);
    void add(Card *card);
    int score();
    ~Hand();

  private:
    Card *cards;
    
}; // Hand class

/*------------------------------------------------------------------------*/

Hand::Hand(Card *cards) - Takes a linked list of Card objects and assigns
  its to the private data member cards.

void Hand::add(Card *card) - Adds a single card to the hand.

int Hand::score() - Computes the score of the hand for Black Jack

Hand::~Hand() - Destructor. destructs the card objects comprising
  the hand object.

ostream &operator<<(ostream &out, const Hand &h) - Inserts the card
  objects into the stream in the format <card_1> <card_2> ... <card_n>.

/*========================================================================*/

class Deck
{
  public:
    Deck();
    bool empty();
    void shuffle();
    Card *dealHand(int cards);
    Card *dealCard();
    ~Deck();

  private:
    int cardsInDeck;
    Card *cards;

    void clear();

}; // Deck class

/*------------------------------------------------------------------------*/

Deck::Deck() - Constructor.  Initializes the object and "shuffles" the
  deck.

bool Deck::empty() - Returns true if the deck is empty; false otherwise.

void Deck::shuffle() - Clears the deck of card if not empty, then builds
  a linked list of 52 playing cards.

Card *Deck::dealHand(int cards) - Deals some number of cards from the deck,
  as specified by the parameter.  Returns these cards as a linked list.

Card *Deck::dealCard() - Randomly removes a single card from the deck
  (i.e., the linked list of cards).

void Deck::clear() - Removes the cards from the deck.

Deck::~Deck() - Removes the cards from the deck by calling clear.

/*========================================================================*/

class BlackJack
{
  public:
    void play();
}; // BlackJack class

/*------------------------------------------------------------------------*/

void BlackJack::play() - Plays the game.