Need help with a card dealing program using classes

I am working on a program that will deal cards using classes. KI have somewhat of a start but am confused on a couple things. Here is what I'm supposed to do:
Construct a class definition that can be used to represent a deck of cards. Each card deck is defined by an integer array of 52 cards and an integer indicating the last card position for undealt cards. The services provided by the class should be the ability to deal a single card from the set of undealt cards, and the ability to shuffle the deck by setting the last card position back to 51.

The main program will deal and display 2 hands of 5 cards, shuffle the deck and then deal and display 2 more hands of 5 cards.

The card representation is like this
suit 1-4 1=clubs, 2 = diamonds, 3 = hearts, 4=spades
value 1 = ace 2-10=value of card, 11 = jack, 12 = queen ,13 = king

I have attempted some of it so far but I don't really know if i'm suppoed to generate 52 random numbers and put the numbers into the array or? Also I don't really know how to deal the cards. I am just overall really confused. Here is what I have so far

Code:

---

#include <iostream>
#include<ctime>
using namespace std;


class Cards
{
private:
        int deck[52];
        int card;

public:
        Cards(int[], int); //Constructor
        void deal(int, int);
        void shuffle(int, int);
};

Cards::Cards(int deck[], int card)
{
  srand(time(NULL));
  int suitRand = rand() % 4 + 1;
  int valRand = rand() % 13 +1;
}

void Cards::deal(int deck, int card)
{

---

All help/advice is appreciated.

It doesn't really matter how you make a shuffled deck, but all the cards need to be in the deck only once. You have to also figure out what to do if someone wants to reshuffle the cards.

I think the instructions are rather clear about dealing -- you have a number that is the place of the top of the deck, and as cards are dealt, the top changes.

But based on the directions, what ints should be stored in the array? It doesn't seem like 1-52 would make sense, since 1-52 has nothing to do with anything so far(does it?). I guess to get started here, I need help on what numbers need to be stored in the 52 locations of my deck[] array, and how I would automatically get the numbers into the array.

Quote:

---

Originally Posted by nick753

But based on the directions, what ints should be stored in the array? It doesn't seem like 1-52 would make sense, since 1-52 has nothing to do with anything so far(does it?). I guess to get started here, I need help on what numbers need to be stored in the 52 locations of my deck[] array, and how I would automatically get the numbers into the array.

---

Can you not have an array of a user-defined type?
So

Code:

---

Struct cards {
int suit;
int card;
};

array[52] cards;

---

Darren, do you not mean

cards array[52];

It's nice if you make sure that everything you post on the forum compiles, especially if you are new to the language.

nick, again, I think the instructions are clear. You can do something like what darren suggests, or if you think that isn't good enough, use the hundreds place for a suit number. For example, if spades is 4, then all the ranks fit in 400. 413 is the king of spades and so on.

Quote:

---

Originally Posted by whiteflags

Darren, do you not mean

cards array[52];

It's nice if you make sure that everything you post on the forum compiles, especially if you are new to the language.

---

I sure did.....Friday afternoon over here! It's been a long week :)

Here is my updated code. I changed the functions to not receive any values, and made the deal function return an int. I have been working on my deal function for a while and came up with something that seems to work except one thing, when suit = 0, it will mess everything up. How can I make sure that suit will never equal 0? Here is my code, another question I have, what in the heck should go in the constructor in this program? I'm sort of confused on that. Thank you guys for helping me out and as always I appreciate any help on any part of this program. BTW the_card is the card I'm dealing.

Code:

---

#include <iostream>
#include<ctime>
using namespace std;


class Cards
{
private:
        int deck[52];
        int card;

public:
        Cards(); //Constructor
        int deal();
        void shuffle();
};

Cards::Cards() //constructor
{
 
}

int Cards::deal()
{
        int i;
        int the_card;
        srand(time(NULL));
 
       

        for (i = 0; i < 52; i++)
        {
        int suit = rand() % (4+1)*100;
        int value = rand() % 13 + 1;
        deck[i] = (suit) + (value);
        }
       
        the_card = deck[51];

        return the_card;
}

---

Code:

---

suit = (1 + rand() % (4 - 1)) * 100;
value = 1 + rand() % (13 - 1);
temp = suit + value;

---

This seems to be what you were missing. Do the math and you will see it finds a random number in the range. One important thing that you were missing was that the number generated could already be in the deck, so only add it to the deck if it is not there; i.e. check all the cards.

Also I could be wrong but I do not think you were supposed to shuffle every time you deal a card.

hmm, to check if two values are the same I would think it's something like

Code:

---

if(temp!= temp)
deck[i]= temp;

---

But I know that's wrong. I did a little searching on google and didn't find much.

And one more thing, what should go in the constructor? So far it doesn't seem like it's even necessary??

Quote:

---

Originally Posted by whiteflags

Code:

---

suit = (1 + rand() % (4 - 1)) * 100;
value = 1 + rand() % (13 - 1);

---

---

That can't be right. % 3 means only three different suits.
You'd want the mod of max - min + 1.

I think I did it right. The reason I did it this way was to prevent the suit from being zero, but 4 will occasionally be the suit and stuff. The method is also repeated here: Eternally Confuzzled - Using rand(). If you suggest something like rand()%4+1 then you would occassionally get 5 so that's also wrong.

Any advice on what to put in my constructor? And how to check and see if 2 suits are identical?

Okay, I think I got this working pretty much like it's supposed to. The one thing that is sort of stumping me, however, is the shuffle function. To shuffle, I was thinking of just allowing all of the cards to be picked from again. Any advice on a good way of doing this? I was thinking about creating another for loop to just re-populate the array with 52 cards, but that just does not seem right for some reason. Also, after I do shuffle the cards, would I just do something like

Code:

---

a.shuffle();
for(int i =1; i < 6; i++) // using same for loop as first time I dealt first hand ??????
        {

        the_card = a.deal();
        cout << the_card << endl;

        }
       
   
        for(int j = 1; j < 6; j++) //using same for loop as the first time I dealt a second                hand???
        {
                the_card = a.deal();
                cout << setw(15) <<  the_card << endl;
        }

---

Here is my whole program, I am hoping someone can look it over and see if I did things like the directions specified, etc. Thanks

Code:

---

#include <iostream>
#include<iomanip>
#include<ctime>
using namespace std;


class Cards
{
private:
        int deck[52];
    int card ;

public:
        Cards(); //Constructor
        int deal();
        void shuffle();
};

Cards::Cards() //constructor
{

        card = 51;
        srand(time(NULL));
 
}

int Cards::deal()
{
int i;
int deck[52];
int the_card;

int suit, value;

int randcard = 1 + rand()% 52;


for (i = 0; i < 52; i++)
{
deck[i]=i;
}

suit = deck[randcard] % (4+1)  * 100;
value = deck[randcard] % 13 + 1;

deck[card] = deck[randcard];
deck[card] =  deck[card-1];

the_card = suit+value;


return the_card;
}

void shuffle ()
{
       

}

int main()
{
        int the_card;
        Cards a;
       
        for(int i =1; i < 6; i++)
        {

        the_card = a.deal();
        cout << the_card << endl;

        }
       
   
        for(int j = 1; j < 6; j++)
        {
                the_card = a.deal();
                cout << setw(15) <<  the_card << endl;
        }
        cin.get();

        return 0;
}

---

I'm a bit late to this thread but you don't have to use a structure and could just use the raw numbers. Suits are composed of a set number of cards so you could translate the number into whatever output you want.

Figuring out how to shuffle the deck by passing through the deck exactly one time and yet ensuring every card is shuffled is a very good exercise. In fact I've used it as an interview question b/c it allows me to see someone work through a problem step by step which is invaluable when it comes to analyzing how different people approach problems.

I'd be interested to see your first attempt at your own shuffle algorithm here in this thread. This will definitely get you thinking and I'm curious as to what you will come up with.

No matter what I try NOTHING seems to work when it comes to trying to making my program not deal the same card twice! I am hoping someone can point me to the right direction with this! The first way I was going about it was the above way, that isn't working. Now I tried to come up with a new way but this way isn't working either. What I am trying to do is put the last card dealt at the end of the array, then decrement the pointer by one every time I deal so that the cards at the end of the array are not deal again(before I shuffle which is just going to reset the pointer back to position 51). Please please please take a look at this and try to tell me what I'm doing wrong this time.

Code:

---

#include <iostream>
#include<iomanip>
#include<ctime>
using namespace std;


class Cards
{
private:
        int deck[52];
        int *card ;

public:
        Cards(); //Constructor
        int deal();
        void shuffle();
};

Cards::Cards() //constructor
{
   
        card = &deck[51];
        srand(time(NULL));
 
}

int Cards::deal()
{
  int i;
  int deck[52];
  int the_card;

  int suit, value;

  int randcard = rand()% 52;
 

  for (i = 0; i < 52; i++)
    {
      deck[i]=i;
    }
 
    suit = deck[randcard] % (4+1)  * 100;
    value = deck[randcard] % 13 + 1;

    *card = deck[randcard];
    *card --;

    the_card = suit+value;


    return the_card;
}

void shuffle ()
  {
       

  }

int main()
{
        int the_card;
        Cards a;
       
        for(int i =1; i < 6; i++)
        {

        the_card = a.deal();
        cout << the_card << endl;

        }
       
   
        for(int j = 1; j < 6; j++)
        {
                the_card = a.deal();
                cout << setw(15) <<  the_card << endl;
        }
        cin.get();

        return 0;
}

---

OK I think I need to help more. Just fill an array with all the card values and use a shuffling algorithm. This meets all the requirements because by filling an array with all the possibilities you ensure that each card is represented once, and with the shuffling algorithm, you give them random placement. What you do with the constructor depends on your expectations. What is the initial state of a card deck? Write out your answer in the constructor.

Do you mean fill the array with the random numbers? That's not really what I am supposed to do. I am supposed to fill the array from 0-51 then add the randomness when I deal the card. Then after the card is pulled from the deck and randomized, I put it in position 51 and decrement the array by 1. Then I pull another card, randomize it, then put that card in position 50, then decrement by 1 again. It seems like I have everything working properly, I am just not putting the card at the end of the array, or I'm not decrementing it correctly? Or both?

>> Do you mean fill the array with the random numbers?

I mean exactly what I said. How else will you know what you've dealt already versus not?

Consider if

Cards mydeck;

creates a pack of cards like you buy at the store (ordered). Now let's assume you've built methods that do what they say.

mydeck.shuffle();
for (int count = 0; count < 52; count++) std::cout << mydeck.deal();

If I do this then I've obviously dealt all the cards out, and notice I only had to shuffle them once. The particular stuff your instructor notes in the assignment like, "The services provided by the class should be the ability to deal a single card from the set of undealt cards, and the ability to shuffle the deck by setting the last card position back to 51," are merely implementation details he would like to see.

Okay, but is there a obvious reason as to why my method is not working? To just take the last card dealt and put it at the end of the array then decrement the pointer down one each time a card is dealt? Am I close? Is that a possible method?

Quote:

---

Originally Posted by Bubba

I'm a bit late to this thread but you don't have to use a structure and could just use the raw numbers. Suits are composed of a set number of cards so you could translate the number into whatever output you want.

Figuring out how to shuffle the deck by passing through the deck exactly one time and yet ensuring every card is shuffled is a very good exercise. In fact I've used it as an interview question b/c it allows me to see someone work through a problem step by step which is invaluable when it comes to analyzing how different people approach problems.

I'd be interested to see your first attempt at your own shuffle algorithm here in this thread. This will definitely get you thinking and I'm curious as to what you will come up with.

---

Here is my take at the shuffle algorithm:

Code:

---

#ifndef CARD_H_
#define CARD_H_

struct Deck_Card
{
  int val;
  int suit;
};

class Card
{
 private:
  Deck_Card Deck[52];
 public:
    Card();
    ~Card();
  void Card_Shuffle(int nn = 52);
  void Show();
};

#endif

---

Code:

---

#include <iostream>
#include "card.h"
#include <cstdlib>
#include <ctime>
using namespace std;

Card:: Card()
{
  int i;
  int j;
  // Generating the ordered set/ordered Deck of Card
  // i to generate number from 1-13
  // j to generate the suites;
  for ( i = 0; i < 13; i++ )
    {
      for(j = 0; j < 4; j++)
        {
          if ( (4*i+j) > 52) break;
          Deck[4*i+j].val = i+1;
          Deck[4*i+j].suit = j;
        }
    }
}
Card::~Card()
{}

void Card::Card_Shuffle(int nn)
{
  // nn is the number of times to switch position of 2 random cards. Default nn=52
  srand(time(NULL));
  Deck_Card temp;
// n and m are the position of 2 cards in a deck.
  int n,m;
  int i;
  for (i = 0 ; i < nn ; i++)
    {
      // generating two random position
    n = rand() % 52;
    m = rand() % 52;
    // n and m must have different values
    while ( n == m)
        {
          n = rand() % 52;
          m = rand() % 52;
        }
    // switch the position
      temp = Deck[n];
      Deck[n] = Deck [m];
      Deck[m] = temp;
    }
}

void Card::Show()
{
  string suit[4] = {"Hearts","Diamonds","Club", "Spades"};
  for (int i = 0; i < 52; i++)
  cout << Deck[i].val << " of "<<suit[ Deck[i].suit] << endl;
}

---

Code:

---

#include <iostream>
#include "card.h"

int main()
{
  Card deck1;
  deck1.Show();
  deck1.Card_Shuffle();
  std:: cout << " Shuffled Deck: " << std::endl;
  deck1.Show();
  return 0;
}

---

Here is my take on this one. This was a good exercise. I don't quite understand what you meant by "passing through the deck exactly one time." What I did was just generate the random positions of two cards in the deck and switch them. The shuffle is quite good after just iterate that for 52 times. I think a better way would be generating a set random unique number from 0 to 51. The uniqueness property makes it harder because I don't think C would check for that. I'll try that method later.
I guess i could use enqueue and dequeue to take the 2 set of 5 cards out. And, if I want to reshuffle the rest of the cards, then I could've use dynamic array for "Deck".

Fortunately that is a pretty poor algorithm, as it should be completely possible to have a card stay in its original position. If you always randomize again when n == m, you are trying too hard.

It's pretty stacked. :p

Nice job on nick's homework, overall.

Quote:

---

Originally Posted by whiteflags

Fortunately that is a pretty poor algorithm, as it should be completely possible to have a card stay in its original position. If you always randomize again when n == m, you are trying too hard.

It's pretty stacked. :p

---

Was this to me or nimitzhunter?:confused: Now I'm getting even more confused!

Of course it's to the other guy: you didn't write a shuffle algorithm!

Quote:

---

Originally Posted by whiteflags

Fortunately that is a pretty poor algorithm, as it should be completely possible to have a card stay in its original position. If you always randomize again when n == m, you are trying too hard.

It's pretty stacked. :p

Nice job on nick's homework, overall.

---

Whiteflags,
You are right. In your opinion, what is a better way to doing this? i think of writing it into something like this:

Code:

---


class Card
{
 private:
  Deck_Card Deck[52];
  Deck_Card * Shuffled_Deck;
  int k; // number of card left in the deck
 public:
  Card();
  ~Card();
  void Card_Shuffle();
  void Show();
  void Deal();
};

---

where the constructor is and the method Card_Shuffle is:

Code:

---

Card:: Card()
{
  k = 52;
    for ( int i = 0; i < 13; i++ )
    {
      for(int j = 0; j < 4; j++)
        {
          if ( (4*i+j) > 52) break;
          Card::Deck[4*i+j].val = i+1;
          Card::Deck[4*i+j].suit = j;
        }
    }
  Shuffled_Deck = new Deck_Card[k];
  for (int i = 0; i < k; i++)
    Shuffled_Deck[i] = Deck[i];
}

void Card::Card_Shuffle()
{
  srand(time(NULL));
  int n;
  for ( int i = 0 ; i < k; i++)
    {
      n = rand() % k;
      Shuffled_Deck[i] = Deck[n];
      Shuffled_Deck[n] = Deck[i];
    }
}

---

I would like to declare " Deck_Card Deck[52];" as:

Code:

---

static Deck_Card Deck[52];

---

But I can't find out how to initialize the static member array.

Quote:

---

Originally Posted by nick753

Okay, but is there a obvious reason as to why my method is not working? To just take the last card dealt and put it at the end of the array then decrement the pointer down one each time a card is dealt? Am I close? Is that a possible method?

---

I really must apologize for kind of ignoring this.

There is a reason what you did does not work. Seeding rand() is very important because even if this

Code:

---

{
  int i;
  int deck[52];
  int the_card;

  int suit, value;

  int randcard = rand()% 52;
 

  for (i = 0; i < 52; i++)
    {
      deck[i]=i;
    }
 
    suit = deck[randcard] % (4+1)  * 100;
    value = deck[randcard] % 13 + 1;

    *card = deck[randcard];
    *card --;

    the_card = suit+value;


    return the_card;
}

---

is perfect, you will get the same sequence of cards no matter when you start the program. And there are compounding problems that make this way less than perfect.

Remember, the index is what is random here, not the value. If you want to choose a random index, instead, that is fine, but you need to rewrite that completely. You have no way of knowing which cards are discarded as of yet. You can change that. Here's how.

You'd still fill an array with card values in that case but you would have to swap the card into the last position of the array after it is going to be returned. OK, so say last starts out at 51. You pick out randcard and swap out deck[randcard] with deck[last--]. Then you pick randcard from 0 to last next time. Get what happened?

This means that calling shuffle() just restores last to 51 for the next deal().

Just as an aside, I would still fill an array with card values. It's simpler, and unless you're really sure what you did for the value currently works (because I'm not), you should change it. Modular arithmetic is kinda different: 0 divides into 52 as evenly as 52 does, so you end up with two possible zero results. This is also why anything like rand() % N; is not as good as it could be ... but this (again) explains it better than I will.

Quote:

---

Originally Posted by nimitzhunter

Whiteflags,
In your opinion, what is a better way to doing this?

---

I was not really concerned about your implementation details. I was pointing out a problem with your shuffling. There are many ways to write a shuffle but in each case you are merely choosing a possible permutation of a finite set out of all the possible sets. The wiki article I've linked to earlier, explains how to do it correctly.