Academic Integrity: tutoring, explanations, and feedback — we don’t complete graded work or submit on a student’s behalf.

create blackjack game in c++ I\'m missing something I just don\'t know what. ple

ID: 3835525 • Letter: C

Question

create blackjack game in c++ I'm missing something I just don't know what. please add comment lines too please

Here is the code for Card.h:


#include<cctype> //Required for toupper()
#include<string> //Required for string
#include<iostream> //Required for ostream
#include<vector> //Required for Vector
#include<ctime> //Required for time()
#include<algorithm> //Required for random_shuffle()
using namespace std;
class Card {
public:
//Constructors
Card(); //default
Card(char asuit, int aRank); //parameterized
//Accessors
int getRank() const;
char getSuit() const;
void displayCard(ostream& outstream) const;
//Comparator
bool operator<(const Card& c) const;
bool operator>(const Card& c) const;
bool operator==(const Card& c) const;
friend ostream &operator<<(ostream &output, const Card &c)
{
output << "Player 1 draws ";
output << "Player 2 draws ";
return output;
}
private:
char suit;
int rank;
};


Here is the code for Card.cpp:


#include "Card.h"
/*------------------------------------------------------------------*/
//Card.cpp - Card class implementation//
/*-----------------------------------------------------------------*/
//Constructors
Card::Card() :rank(2), suit('S')
{
}
Card::Card(char ch, int i) : rank(i)
{
suit = toupper(ch);
}
//Accessor Methods
int Card::getRank() const
{
return rank;
}
char Card::getSuit() const
{
return suit;
}
//Formatted Display Method
void Card::displayCard(ostream& out) const
{
string suitString;
switch (suit){
case 'S':
suitString = "Spades";
break;
case 'H':
suitString = "Hearts";
break;
case 'D':
suitString = "Diamonds";
break;
case 'C':
suitString = "Clubs";
break;
default:
suitString = "Invalid Suit";
}
if (rank >= 2 && rank<11){
out << rank << "of" << suitString;
}
else{
switch (rank){
case 11:
out << "JACK of " << suitString;
break;
case 12:
out << "Queen of " << suitString;
break;
case 13:
out << "KING of " << suitString;
break;
case 14:
out << "ACE of " << suitString;
break;
}
}
return;
}
bool Card::operator==(const Card& c) const
{
Card card1;
Card card2;
if (card1 == card2)
{
return true;
}
else
{
return false;
}
}
bool Card::operator>(const Card& c) const
{
Card card1;
Card card2;
return card1 > card2;
}
bool Card::operator<(const Card& c) const
{
Card card1;
Card card2;
return card1 < card2;
}


Here is the code for CardDeck.h:


#include "Card.cpp"
/*----------------------------------------------------------------*/
//CardDeck.h
/*-----------------------------------------------------------------*/
class CardDeck{
public:
CardDeck();
void shuffleDeck();
bool isEmpty() const; //return true if empty
Card draw();
private:
vector<Card> theDeck;
vector<Card> deltCards;
};


Here is the code for CardDeck.cpp:


#include <iostream>
#include "CardDeck.h"
using namespace std;
/*------------------------------------------------------------------------*/
/*CardDeck.cpp */
/*------------------------------------------------------------------------*/


CardDeck::CardDeck(){
/*13 cards in each suit */
/*52 new card */
for (int i = 2; i<15; ++i) {
theDeck.push_back(Card('S', i));
theDeck.push_back(Card('H', i));
theDeck.push_back(Card('D', i));
theDeck.push_back(Card('C', i));
}
srand(time(NULL)); //Must seed RNG 1time!
}
Card CardDeck::draw(){
/*Draw and return one card. */
if (theDeck.empty()) {
exit(1);
}
Card aCard = theDeck.back(); //Draw card.
theDeck.pop_back(); //Remove card
//Retain card for shuffle.
deltCards.push_back(aCard);
return(aCard);
}
void CardDeck::shuffleDeck() {
/*Replace drawn cards */
for (int i = 0; i<deltCards.size(); ++i){
theDeck.push_back(deltCards[i]);
}
//Clear the vector
deltCards.resize(0);
//Use the top level function from algorithm
random_shuffle(theDeck.begin(), theDeck.end());
}
bool CardDeck::isEmpty() const {
if(theDeck.size() == 0)
return true;
return false; 
}


And the Main.cpp is:


class Player
{
public:
Player(CardDeck&);
Card draw();
void addpoints(int);
int score() const;
void replaceCard(CardDeck&);
private:
Card myCards[3];
int myScore;
int removedCard;
};
Player::Player(CardDeck &aCardDeck)
{
myScore = 0;
for (int i = 0; i < 3; i++)
myCards[i] = aCardDeck.draw();
removedCard = 0;
}
Card Player::draw()
{
removedCard = rand() % 3;
return myCards[removedCard];
}
void Player::addpoints(int howMany)
{
myScore += howMany;
}
int Player::score() const
{
return myScore;
}
void Player::replaceCard(CardDeck& aCardDeck)
{
myCards[removedCard] = aCardDeck.draw();
}

int main()
{
CardDeck theDeck;
theDeck.shuffleDeck();
Player player1(theDeck);
Player player2(theDeck);
while (! theDeck.isEmpty())
{
Card card1 = player1.draw();
cout << "Player 1 draws " << card1 << endl;
Card card2 = player2.draw();
cout << "Player 2 draws " << card2 << endl;
if (card1.getRank()==card2.getRank())
{
player1.addpoints(1);
player2.addpoints(1);
cout << "Players tie" << endl;
}
else if (card1.getRank()>card2.getRank())
{
player1.addpoints(2);
cout << "Player 1 wins round" << endl;
}
else
{
player2.addpoints(2);
cout << "Player 2 wins round" << endl;
}

player1.replaceCard(theDeck);
player2.replaceCard(theDeck);
}
cout << "Player 1's score is " << player1.score() << endl;
cout << "Player 2's score is " << player2.score() << endl;
getchar();
//getchar();
return 0;
}


Explanation / Answer

//Card.h
#ifndef CARD_H
#define CARD_H
#include<cctype> //Required for toupper()
#include<string> //Required for string
#include<iostream> //Required for ostream
#include<vector> //Required for Vector
#include<ctime> //Required for time()
#include<algorithm> //Required for random_shuffle()
using namespace std;

class Card {
public:
   //Constructors
   Card(); //default
   Card(char asuit, int aRank); //parameterized
   //Accessors
   int getRank() const;
   char getSuit() const;
   void displayCard(ostream& outstream) const;
   //Comparator
   bool operator<(const Card& c) const;
   bool operator>(const Card& c) const;
   bool operator==(const Card& c) const;
   friend ostream &operator<<(ostream &output, const Card &c)
   {
       output << "Player 1 draws ";
       output << "Player 2 draws ";
       return output;
   }
private:
   char suit;
   int rank;
};

#endif CARD_H

---------------------------------------------------------------------------------------------------------------

//Card.cpp
#include<iostream>
#include<string>
#include "Card.h"
using namespace std;
/*------------------------------------------------------------------*/
//Card.cpp - Card class implementation//
/*-----------------------------------------------------------------*/
//Constructors
Card::Card()
{
   suit='S';
   rank=2;
}
Card::Card(char ch, int i)
{
   suit = toupper(ch);
   rank=i;
}
//Accessor Methods
int Card::getRank() const
{
   return rank;
}
char Card::getSuit() const
{
   return suit;
}
//Formatted Display Method
void Card::displayCard(ostream& out) const
{
   string suitString;
   switch (suit){
   case 'S':
       suitString = "Spades";
       break;
   case 'H':
       suitString = "Hearts";
       break;
   case 'D':
       suitString = "Diamonds";
       break;
   case 'C':
       suitString = "Clubs";
       break;
   default:
       suitString = "Invalid Suit";
   }
   if (rank >= 2 && rank<11){
       out << rank << "of" << suitString;
   }
   else{
       switch (rank){
       case 11:
           out << "JACK of " << suitString;
           break;
       case 12:
           out << "Queen of " << suitString;
           break;
       case 13:
           out << "KING of " << suitString;
           break;
       case 14:
           out << "ACE of " << suitString;
           break;
       }
   }
   return;
}
bool Card::operator==(const Card& c) const
{
   Card card1;
   Card card2;
   if (card1 == card2)
   {
       return true;
   }
   else
   {
       return false;
   }
}
bool Card::operator>(const Card& c) const
{
   Card card1;
   Card card2;
   return card1 > card2;
}
bool Card::operator<(const Card& c) const
{
   Card card1;
   Card card2;
   return card1 < card2;
}

---------------------------------------------------------------------------------------------------------------

//Player.h
#ifndef PLAYER_H
#define PLAYER_H
#include<cctype> //Required for toupper()
#include<string> //Required for string
#include<iostream> //Required for ostream
#include<vector> //Required for Vector
#include<ctime> //Required for time()
#include<algorithm> //Required for random_shuffle()
#include "Card.h"
#include "CardDeck.h"
using namespace std;
class Player
{
public:
   Player(CardDeck&);
   Card draw();
   void addpoints(int);
   int score() const;
   void replaceCard(CardDeck&);
private:
   Card myCards[3];
   int myScore;
   int removedCard;
};

#endif PLAYER_H

---------------------------------------------------------------------------------------------------------------


//Player.cpp
#include<iostream> //Required for ostream
#include "Player.h"
#include "CardDeck.h"
#include "Card.h"

using namespace std;
Player::Player(CardDeck &aCardDeck)
{
   myScore = 0;
   for (int i = 0; i < 3; i++)
       myCards[i] = aCardDeck.draw();
   removedCard = 0;
}
Card Player::draw()
{
   removedCard = rand() % 3;
   return myCards[removedCard];
}
void Player::addpoints(int howMany)
{
   myScore += howMany;
}
int Player::score() const
{
   return myScore;
}
void Player::replaceCard(CardDeck& aCardDeck)
{
   myCards[removedCard] = aCardDeck.draw();
}

---------------------------------------------------------------------------------------------------------------

//CardDeck.h
#ifndef CARD_DECK_H
#define CARD_DECK_H
#include<iostream>
using namespace std;
/*----------------------------------------------------------------*/
//CardDeck.h
/*-----------------------------------------------------------------*/
class CardDeck{
public:
   CardDeck();
   void shuffleDeck();
   bool isEmpty() const; //return true if empty
   Card draw();
private:
   vector<Card> theDeck;
   vector<Card> deltCards;
};

#endif CARD_DECK_H

---------------------------------------------------------------------------------------------------------------


//CardDeck.cpp
#include <iostream>
#include<time.h>
#include "Card.h"
#include "CardDeck.h"
using namespace std;
/*------------------------------------------------------------------------*/
/*CardDeck.cpp */
/*------------------------------------------------------------------------*/


CardDeck::CardDeck()
{
   /*13 cards in each suit */
   /*52 new card */
   for (int i = 2; i<15; ++i) {
       theDeck.push_back(Card('S', i));
       theDeck.push_back(Card('H', i));
       theDeck.push_back(Card('D', i));
       theDeck.push_back(Card('C', i));
   }
   srand(time(NULL)); //Must seed RNG 1time!
}
Card CardDeck::draw(){
   /*Draw and return one card. */
   if (theDeck.empty()) {
       exit(1);
   }
   Card aCard = theDeck.back(); //Draw card.
   theDeck.pop_back(); //Remove card
   //Retain card for shuffle.
   deltCards.push_back(aCard);
   return(aCard);
}
void CardDeck::shuffleDeck() {
   /*Replace drawn cards */
   for (int i = 0; i<deltCards.size(); ++i){
       theDeck.push_back(deltCards[i]);
   }
   //Clear the vector
   deltCards.resize(0);
   //Use the top level function from algorithm
   random_shuffle(theDeck.begin(), theDeck.end());
}
bool CardDeck::isEmpty() const {
   if(theDeck.size() == 0)
       return true;
   return false;
}

---------------------------------------------------------------------------------------------------------------

//Main.cpp
#include<iostream>
#include "Card.h"
#include "CardDeck.h"
#include "Player.h"

using namespace std;
int main()
{
   CardDeck theDeck;
   theDeck.shuffleDeck();
   Player player1(theDeck);
   Player player2(theDeck);
   while (! theDeck.isEmpty())
   {
       Card card1 = player1.draw();
       cout << "Player 1 draws " << card1 << endl;
       Card card2 = player2.draw();
       cout << "Player 2 draws " << card2 << endl;
       if (card1.getRank()==card2.getRank())
       {
           player1.addpoints(1);
           player2.addpoints(1);
           cout << "Players tie" << endl;
       }
       else if (card1.getRank()>card2.getRank())
       {
           player1.addpoints(2);
           cout << "Player 1 wins round" << endl;
       }
       else
       {
           player2.addpoints(2);
           cout << "Player 2 wins round" << endl;
       }

       player1.replaceCard(theDeck);
       player2.replaceCard(theDeck);
   }
   cout << "Player 1's score is " << player1.score() << endl;
   cout << "Player 2's score is " << player2.score() << endl;
   getchar();
  
   return 0;
}

---------------------------------------------------------------------------------------------------------------

Sample Output:

Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 2 wins round
Player 1 draws Player 1 draws Player 2 draws
Player 2 draws Player 1 draws Player 2 draws
Player 1 wins round
Player 1's score is 18
Player 2's score is 28

Related Questions

create a simple GUI flashcard program that reads data from a file. Instructions:
Question #3571664
create a simple TCP based console chat room using C#. Any help would be really a
Question #3777190
create a simple graphic indicating the distance in map units between the genes s
Question #8134
create a simple interactive application (command line) that will allow company m
Question #3828443
create a simple java application for a rug store. The store manages the rug info
Question #3696613
create a simple logic game in which the computer choses a random string of chara
Question #3620880
create a single function in matlab that can both encrypt and decrypt a message u
Question #3703040
create a single function in matlab that can both encrypt and decrypt a message u
Question #3704138

Navigate

Previous
create battleship game in c++ on 10x10 grid of 0s. Put the game into a loop that
Next
create c++ to read the data and include these functions int menu(); int readFile

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.