Question

void card:: setNum(int n) {

assert(n >= 1 && n <= 13);

num = n;

}

void card::setSuit(char s) {

assert(s == 'C' || s == 'D' || s == 'H' || s == 'S');

suit = s;

}

int card::getNum() {

assert(num >= 1 && num <= 13);

return num;

}

char card::getSuit() {

assert(suit == 'C' || suit == 'D' || suit == 'H' || suit == 'S');

return suit;

}

string card:: read() {

string output="";

if (num == 1) {

output= "Ace";

}

else if (num == 11) {

output = "Jack";

}

else if (num == 12) {

output = "Queen";

}

else if (num == 13) {

output = "King";

}

else {

output = getNum();

}

output += " of ";

if (suit == 'C') {

output += "Clubs";

}

else if (suit == 'D') {

output += "Diamonds";

}

else if (suit == 'H') {

output += "Hearts";

}

else if (suit == 'S') {

output += "Spades";

}

return output;

}

card:: card(){

num = 0;

suit = 'X';

}

card::card(int n, char s) {

setNum(n);

setSuit(s);

}

Write C++ function implementations.

Problem 3: (Hand) Write the member function implementations for the class hand, which simulates a hand of 2 cards, into the file hand .cpp. The relative strength of 2 hands are determined by the following rules: A pair (two cards of the same number) is the strongest hand. Two cards of the same suit is the next strongest hand. Two cards of different numbers and suits is the weakest hand. Within the same kind of hands, the stronger land is determined by the larger number. If two hands are of the same kind and largest numbers are the same, the stronger hand is determined by the smaller number. If all above fails, the two hands are of equal strength. Le all suits are of equal strength. 2 is the weakest number. An Ace is stronger than a King. Here are some examples: 3 is stronger than 9A24. 9A2A is stronger than 8 7 8 7 is stronger than 8 6 8 is stronger than A J 3 has the same strength as 3 The public data members card cl, c2 represent the 2 cards of a hand. The public member function bool operator <Chand rhs) returns true if rhs is the stronger hand and returus false otherwise. The public member function bool operator (hand rhs) returns true if the two hands are of equal strength and returms false otherwise. The public member functions bool operator Chand rhs) bool operator Chand rhs); bool operator Chand rhs) are defined similarly. Hint. Using operator< all other operators can be defined in one line. In doing so, you may find the this pointer useful.

Answer 1

Complete Program:

NOTE:
Please include the card.h, card.cpp, deck.h, deck.cpp, shuffle.h, and main.cpp files to run this program.

Note: Please include the card.h, card.cpp, deck.h, deck.cpp, shuffle.h, and main.cpp files to run this program.
Then run the program.

Sample Output:

CODE TO COPY:

File: hand.h

// hand class specification
#pragma once
#include "card.h"

class hand
{
public:
   card c1, c2;
   bool operator<(hand rhs);
   bool operator>(hand rhs);
   bool operator<=(hand rhs);
   bool operator>=(hand rhs);
   bool operator==(hand rhs);
}; // end of hand.h

File: hand.cpp

// deck class implementation
#include "hand.h"
#include <cassert>

// operator< implementation
bool hand::operator<(hand rhs)
{
   int lhsc1n = this->c1.getNum();
   int lhsc2n = this->c2.getNum();
   char lhsc1s = this->c1.getSuit();
   char lhsc2s = this->c2.getSuit();

   int rhsc1n = rhs.c1.getNum();
   int rhsc2n = rhs.c2.getNum();
   char rhsc1s = rhs.c1.getSuit();
   char rhsc2s = rhs.c2.getSuit();

   // make the Ace as the largest number
   if (lhsc1n == 1)
       lhsc1n = 14;

   if (lhsc2n == 1)
       lhsc2n = 14;

   if (rhsc1n == 1)
       rhsc1n = 14;

   if (rhsc2n == 1)
       rhsc2n = 14;
  

   // A pair (two cards of the same number) is the strongest hand.
   if (lhsc1n != lhsc2n && rhsc1n == rhsc2n)
   {
       return true;
   }
  
   if (lhsc1n == lhsc2n && rhsc1n != rhsc2n)
   {
       return false;
   }

   // Two cards of the same suit is the next strongest hand.
   if (lhsc1s != lhsc2s && rhsc1s == rhsc2s)
   {
       return true;
   }
  
   if (lhsc1s == lhsc2s && rhsc1s != rhsc2s)
   {
       return false;
   }

   // Two cards of different numbers and suits is the weakest hand.
   if ((lhsc1n != lhsc2n && lhsc1s != lhsc2s)
       && (rhsc1n == rhsc2n || rhsc1s == rhsc2s))
   {
       return true;
   }
  
   if ((lhsc1n == lhsc2n || lhsc1s == lhsc2s)
       && (rhsc1n != rhsc2n && rhsc1s != rhsc2s))
   {
       return false;
   }

   // Within the same kind of hands, the stronger hand is
   // determined by the larger number.
   if (lhsc1s == lhsc2s && rhsc1s == rhsc2s)
   {
       if ((lhsc1n > rhsc1n && lhsc1n > rhsc2n)
           || (lhsc2n > rhsc1n && lhsc2n > rhsc2n))
       {
           return false;
       }
       else if ((lhsc1n < rhsc1n && lhsc2n < rhsc1n)
           || (lhsc1n < rhsc2n && lhsc2n < rhsc2n))
       {
           return true;
       }
   }

   // If two hands are of the same kind and the larger
   // numbers are the same, the stronger hand is given by
   // the hand whose smaller number is larger.
   if (lhsc1s == lhsc2s && rhsc1s == rhsc2s)
   {
       int larger1, larger2;
       int smaller1, smaller2;

       if (lhsc1n >= lhsc2n)
       {
           larger1 = lhsc1n;
           smaller1 = lhsc2n;
       }
       else
       {
           larger1 = lhsc2n;
           smaller1 = lhsc1n;
       }

       if (rhsc1n >= rhsc2n)
       {
           larger2 = rhsc1n;
           smaller2 = rhsc2n;
       }
       else
       {
           larger2 = rhsc2n;
           smaller2 = rhsc1n;
       }

       if (larger1 == larger2)
       {
           if (smaller1 < smaller2)
               return true;
           else
               return false;
       }
   }

   // If all above fails, the two hands are of equal strength.
   // i.e., all suits are of equal strength.
   return false;

}

// operator== implementation
bool hand::operator==(hand rhs)
{
   return !(*this < rhs || rhs < *this);
}

// operator<= implementation
bool hand::operator<=(hand rhs)
{
   return !(rhs < *this);
}

// operator> implementation
bool hand::operator>(hand rhs)
{
   return !(*this <= rhs);
}

// operator>= implementation
bool hand::operator>=(hand rhs)
{
   return !(*this < rhs);
}