I need help with a Blackjack game.

I'm writing a simple Blackjack game, but I'm having a problem. This is my code so far:

Code:

---

#include <iostream>
#include <cmath>
#include <ctime>
#include <cstdlib>

using namespace std;
int drawCard();

int main()
{
    int i;
    for(i = 1; i < 53; i++){
        cout<< "Card "<< i<< " is "<< drawCard()<< ".\n";
    }
}

int drawCard() {
    int deck[53];
    int loop;
    while(loop != 0) {
        int deck[53] = {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
        loop = 0;
    }
    int cardToDraw;
    time_t now;//Sets now to equal the current time.
    time(&now);
    srand(now++);//Uses the current time as the seed for random numbers.
    cardToDraw = 0;//Draws the 0 card. This is needed to start the loop.
    while(deck[cardToDraw] == 0) {//If the chosen card is gone, it will choose a new one.
        cardToDraw = (rand() % 52);//Generates a random number between 0 and 52. This will be the card that is drawn.
        cout<< "A card was chosen.\n";//Debugging line.
    }
    cout<< "cardToDraw = "<< cardToDraw<< ".\n";//Debugging line.
    cout<< now;//Debugging line.
    return cardToDraw;
    deck[cardToDraw] = 0;//Removes the drawn card from the deck.
}

---

Forgive me if it's messy or full of problems; I'm pretty new to programming.
My problem is with the while(deck[cardToDraw] == 0) loop within the drawCard function (line 29). I can't get this loop to run for some reason, even though deck[cardToDraw] should equal 0. When I run the program, every drawn card is equal to 0. Does anyone know why this loop won't run? Also, if you notice any other errors, please let me know.

First, you need the code to remember the current state of the cards from one call to the next.
Also, artificially starting the array at subscript 1 tends to be more trouble than it's worth (it makes your next step wrong for starters).

This you do by declaring

Code:

---

static int deck[5] = {1,1,1,1

---

Also,

Code:

---

    return cardToDraw;
    deck[cardToDraw] = 0;//Removes the drawn card from the deck.

---

Swap these over, the assignment never happens as it is after the return statement.

Also

Code:

---

    time_t now;//Sets now to equal the current time.
    time(&now);
    srand(now++);//Uses the current time as the seed for random numbers.

---

Do this exactly ONCE in main().
In a fast running program such as this, the effective value of now will be a constant.
So you're always going to get the same rand()'s out of it.


FWIW, consider the idea of a deck class, with methods called shuffle and draw.

Quote:

---

Originally Posted by Salem

First, you need the code to remember the current state of the cards from one call to the next.
Also, artificially starting the array at subscript 1 tends to be more trouble than it's worth (it makes your next step wrong for starters).

This you do by declaring

Code:

---

static int deck[5] = {1,1,1,1

---

---

The last line is supposed to remove the drawn card from the deck (by setting its value to 0), so it should remember the current state AFAIK. Since the while loop that initiates the array sets loop to 0, it should only run the first time, right?

I had the array start at 0 because a value of 0 is needed to run the loop that chooses a card. If the array doesn't include a value of 0, deck[cardToDraw] will never equal 0, so it will never choose a new card.

Quote:

---

Originally Posted by Salem

Also,

Code:

---

    return cardToDraw;
    deck[cardToDraw] = 0;//Removes the drawn card from the deck.

---

Swap these over, the assignment never happens as it is after the return statement.

---

I just realized that return cardToDraw should actually be return deck[cardToDraw]. I want to return the value of the card, not the position in the array.

So, if I do this:

Code:

---

  deck[cardToDraw] = 0;//Removes the drawn card from the deck.
  return deck[cardToDraw];

---

Won't it just return 0 every time, since the value of the card is set to 0 before it's returned?

Quote:

---

Originally Posted by Salem

Also

Code:

---

    time_t now;//Sets now to equal the current time.
    time(&now);
    srand(now++);//Uses the current time as the seed for random numbers.

---

Do this exactly ONCE in main().
In a fast running program such as this, the effective value of now will be a constant.
So you're always going to get the same rand()'s out of it.

---

That's why I did srand(now++);. I was hoping that that would add one to the seed every time the function is called. Is that not how it works? To be honest, I'm not exactly sure what srand does. I've looked it up and read about it, but I still don't completely understand it.

Also, doesn't now need to be in the function, since that's where the random numbers are generated? If I put it in main() instead, I'm pretty sure it would just return an undeclared variable error.

Quote:

---

Originally Posted by Salem

FWIW, consider the idea of a deck class, with methods called shuffle and draw.

---

I have no idea what any of that means. I'll look it up later, but I have a feeling it will be way over my head. I have experience with HTML classes, but I have a feeling they're not similar.

Edit: By the way, everything in main() is for debugging purposes ATM. It's not permanent.

Quote:

---

Originally Posted by wipeout4wh

The last line is supposed to remove the drawn card from the deck (by setting its value to 0), so it should remember the current state AFAIK. Since the while loop that initiates the array sets loop to 0, it should only run the first time, right?

---

The last line will never get run, because it is after the return.

Quote:

---

I had the array start at 0 because a value of 0 is needed to run the loop that chooses a card. If the array doesn't include a value of 0, deck[cardToDraw] will never equal 0, so it will never choose a new card.

---

Use a do-while loop to do this instead.

Quote:

---

I just realized that return cardToDraw should actually be return deck[cardToDraw]. I want to return the value of the card, not the position in the array.

So, if I do this:

Code:

---

  deck[cardToDraw] = 0;//Removes the drawn card from the deck.
  return deck[cardToDraw];

---

Won't it just return 0 every time, since the value of the card is set to 0 before it's returned?

---

Save it to a temporary variable, clear it from the array, and return the temporary.

Quote:

---

That's why I did srand(now++);. I was hoping that that would add one to the seed every time the function is called. Is that not how it works? To be honest, I'm not exactly sure what srand does. I've looked it up and read about it, but I still don't completely understand it.

Also, doesn't now need to be in the function, since that's where the random numbers are generated? If I put it in main() instead, I'm pretty sure it would just return an undeclared variable error.

---

srand sets a global variable. rand() will use that variable to generate a random number, and increment it itself.

You need to call srand in main so that each time you run the game, the chain of random numbers starts at a different point.

Quote:

---

Originally Posted by King Mir

The last line will never get run, because it is after the return.

Use a do-while loop to do this instead.



Save it to a temporary variable, clear it from the array, and return the temporary.

srand sets a global variable. rand() will use that variable to generate a random number, and increment it itself.

You need to call srand in main so that each time you run the game, the chain of random numbers starts at a different point.

---

Thanks. I have the do... while loop and the temporary variable done. The return is at the end, and it's at least choosing cards now. I put the time stuff and srand(now) in main(), but now it's generating ridiculously high values for the cards. Here's the output:

Code:

---

A card was chosen.
cardToDraw = 11.
Card 1 is 4674324.
A card was chosen.
cardToDraw = 43.
Card 2 is 2009310510.
A card was chosen.
cardToDraw = 7.
Card 3 is 2009339772.
A card was chosen.
cardToDraw = 43.
Card 4 is 2009310510.
A card was chosen.
cardToDraw = 45.
Card 5 is 2358800.
A card was chosen.
cardToDraw = 4.
Card 6 is 2358680.
A card was chosen.
cardToDraw = 19.
Card 7 is 2009261398.
A card was chosen.
cardToDraw = 31.
Card 8 is 2358840.
A card was chosen.
cardToDraw = 4.
Card 9 is 2358680.
A card was chosen.
cardToDraw = 31.
Card 10 is 2358840.
A card was chosen.
cardToDraw = 1.
Card 11 is 2358624.
A card was chosen.
cardToDraw = 10.
Card 12 is 2009261348
A card was chosen.
cardToDraw = 11.
Card 13 is 5316432.
A card was chosen.
cardToDraw = 29.
Card 14 is 2358708.
A card was chosen.
cardToDraw = 11.
Card 15 is 5316432.
A card was chosen.
cardToDraw = 13.
Card 16 is 5316432.
A card was chosen.
cardToDraw = 31.
Card 17 is 2358840.
A card was chosen.
cardToDraw = 9.
Card 18 is 4000.
A card was chosen.
cardToDraw = 30.
Card 19 is 1.
A card was chosen.
cardToDraw = 50.
Card 20 is 2009463968
A card was chosen.
cardToDraw = 16.
Card 21 is 4000.
A card was chosen.
cardToDraw = 47.
Card 22 is 17.
A card was chosen.
cardToDraw = 20.
Card 23 is 5316432.
A card was chosen.
cardToDraw = 0.
Card 24 is 2009471864
A card was chosen.
cardToDraw = 30.
Card 25 is 1.
A card was chosen.
cardToDraw = 34.
Card 26 is -1.
A card was chosen.
cardToDraw = 15.
Card 27 is 2009269136
A card was chosen.
cardToDraw = 16.
Card 28 is 4000.
A card was chosen.
cardToDraw = 13.
Card 29 is 5316432.
A card was chosen.
cardToDraw = 47.
Card 30 is 17.
A card was chosen.
cardToDraw = 19.
Card 31 is 2009261398
A card was chosen.
cardToDraw = 41.
Card 32 is 4649038.
A card was chosen.
cardToDraw = 0.
Card 33 is 2009471864
A card was chosen.
cardToDraw = 39.
Card 34 is 1.
A card was chosen.
cardToDraw = 30.
Card 35 is 1.
A card was chosen.
cardToDraw = 36.
Card 36 is 2009339602
A card was chosen.
cardToDraw = 40.
Card 37 is 2.
A card was chosen.
cardToDraw = 39.
Card 38 is 1.
A card was chosen.
cardToDraw = 13.
Card 39 is 5316432.
A card was chosen.
cardToDraw = 21.
Card 40 is 2358748.
A card was chosen.
cardToDraw = 23.
Card 41 is 1.
A card was chosen.
cardToDraw = 34.
Card 42 is -1.
A card was chosen.
cardToDraw = 1.
Card 43 is 2358624.
A card was chosen.
cardToDraw = 25.
Card 44 is 2.
A card was chosen.
cardToDraw = 30.
Card 45 is 1.
A card was chosen.
cardToDraw = 33.
Card 46 is 2009146752
A card was chosen.
cardToDraw = 4.
Card 47 is 2358680.
A card was chosen.
cardToDraw = 0.
Card 48 is 2009471864
A card was chosen.
cardToDraw = 4.
Card 49 is 2358680.
A card was chosen.
cardToDraw = 38.
Card 50 is 4649036.
A card was chosen.
cardToDraw = 38.
Card 51 is 4649036.
A card was chosen.
cardToDraw = 8.
Card 52 is 2358765.

---

And here's drawCard():

Code:

---

int drawCard() {
    int deck[52];
    int cardToDraw;
    int drawnCard;
    int loop;
    while (loop != 0) {
        int deck[52] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
        loop = 0;
    }
    do {
        cardToDraw = (rand() % 52);//Generates a random number between 0 and 51. This will be the card that is drawn.
        cout<< "A card was chosen.\n";//Debugging line.
    } while (deck[cardToDraw] == 0);
    cout<< "cardToDraw = "<< cardToDraw<< ".\n";//Debugging line.
    drawnCard = deck[cardToDraw];
    deck[cardToDraw] = 0;//Removes the drawn card from the deck.
    return drawnCard;
}

---

main() is the same as before, but with time_t now;, time(&now);, and srand(now); added.

Edit: it's also repeating cards... none of the cards are being set to 0 after they're drawn.

Edit: Also, am I using the right modulus for rand()? I want it to generate values from 0 - 51. It seems to be doing that so far, but I figured I would ask just to be sure.

You never initialize the value of your deck of cards to anything. (You do temporarily create a brand new array, also called deck, that isn't the same as the deck you started with, but that new deck is destroyed when the while loop stops, and the original uninitialized deck remains.) The normal thing to do, I think, would be to pass the deck back and forth from main to your draw function (this would also allow you to pass the deck to, say, a "shuffle" function as well).

Quote:

---

Originally Posted by tabstop

You never initialize the value of your deck of cards to anything. (You do temporarily create a brand new array, also called deck, that isn't the same as the deck you started with, but that new deck is destroyed when the while loop stops, and the original uninitialized deck remains.) The normal thing to do, I think, would be to pass the deck back and forth from main to your draw function (this would also allow you to pass the deck to, say, a "shuffle" function as well).

---

Code:

---

    while (loop != 0) {
        deck[52] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
        loop = 0;
    }

---

Would leaving the int out work?

Edit: Leaving int and [52] out works fine. It's still repeating numbers, though.

I don't know how to pass variables between functions yet, but wouldn't a shuffle function be kind of pointless since it's already choosing the cards in a random order?

No, leaving the int out would not work.

A shuffle function would not normally be pointless, since most players frown at you dealing cards out of the middle of the deck. Also, sometimes people play so many games that you run out of cards.

Leaving both int and [52] out works, leaving this:

Code:

---

    while (loop != 0) {
        deck = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
        loop = 0;
    }

---

I see your point about running out of cards, though... if this deck runs out of cards, it will get stuck in an infinite loop trying to draw a new card.

Define "works". It doesn't compile, unless you've changed a definition above it somewhere.

It compiles in Code::Blocks with one warning.

Code:

---

C:\Documents and Settings\David\My Documents\Programming\Blackjack\main.cpp|28|warning: extended initializer lists only available with -std=c++0x or -std=gnu++0x|

---

It even initiates the array.

Code:

---

cardToDraw = 21.
Card 1 is 6.
cardToDraw = 43.
Card 2 is 11.
cardToDraw = 19.
Card 3 is 5.
cardToDraw = 40.
Card 4 is 11.
cardToDraw = 30.
Card 5 is 8.
cardToDraw = 1.
Card 6 is 1.
cardToDraw = 41.
Card 7 is 11.
cardToDraw = 11.
Card 8 is 3.
cardToDraw = 11.
Card 9 is 3.
cardToDraw = 30.
Card 10 is 8.
cardToDraw = 17.
Card 11 is 5.
cardToDraw = 33.
Card 12 is 9.
cardToDraw = 42.
Card 13 is 11.
cardToDraw = 2.
Card 14 is 1.
cardToDraw = 34.
Card 15 is 9.
cardToDraw = 16.
Card 16 is 5.
cardToDraw = 4.
Card 17 is 2.
cardToDraw = 13.
Card 18 is 4.
cardToDraw = 7.
Card 19 is 2.
cardToDraw = 24.
Card 20 is 7.
cardToDraw = 3.
Card 21 is 1.
cardToDraw = 7.
Card 22 is 2.
cardToDraw = 34.
Card 23 is 9.
cardToDraw = 4.
Card 24 is 2.
cardToDraw = 25.
Card 25 is 7.
cardToDraw = 22.
Card 26 is 6.
cardToDraw = 9.
Card 27 is 3.
cardToDraw = 24.
Card 28 is 7.
cardToDraw = 5.
Card 29 is 2.
cardToDraw = 43.
Card 30 is 11.
cardToDraw = 42.
Card 31 is 11.
cardToDraw = 26.
Card 32 is 7.
cardToDraw = 16.
Card 33 is 5.
cardToDraw = 11.
Card 34 is 3.
cardToDraw = 51.
Card 35 is 13.
cardToDraw = 48.
Card 36 is 13.
cardToDraw = 6.
Card 37 is 2.
cardToDraw = 37.
Card 38 is 10.
cardToDraw = 37.
Card 39 is 10.
cardToDraw = 34.
Card 40 is 9.
cardToDraw = 2.
Card 41 is 1.
cardToDraw = 37.
Card 42 is 10.
cardToDraw = 8.
Card 43 is 3.
cardToDraw = 12.
Card 44 is 4.
cardToDraw = 49.
Card 45 is 13.
cardToDraw = 50.
Card 46 is 13.
cardToDraw = 0.
Card 47 is 1.
cardToDraw = 23.
Card 48 is 6.
cardToDraw = 19.
Card 49 is 5.
cardToDraw = 11.
Card 50 is 3.
cardToDraw = 22.
Card 51 is 6.
cardToDraw = 44.
Card 52 is 12.

---

My only problem now is getting it to set each card to 0 as it's drawn.

Then you have done something other than you posted. Even in Code::Blocks you get two errors (expected primary-expression before curlybrace, expected semicolon before curlybrace). It is never legal to assign to an actual array.

This is the full code:

Code:

---

#include <iostream>
#include <cmath>
#include <ctime>
#include <cstdlib>

using namespace std;
int drawCard();

int main()
{
    time_t now;//Sets now to equal the current time.
    time(&now);
    srand(now);//Uses the current time as the seed for random numbers.
    int i;
    for(i = 1; i < 53; i++){
        cout<< "Card "<< i<< " is "<< drawCard()<< ".\n";
    }
}

int drawCard() {

    int deck[52];
    int cardToDraw;
    int drawnCard;
    int loop;

    while (loop != 0) {
        deck = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
        loop = 0;
    }
    do {
        cardToDraw = (rand() % 52);//Generates a random number between 0 and 51. This will be the card that is drawn.
    } while (deck[cardToDraw] == 0);//If the card is already gone (equal to 0), a new one will be chosen.
    cout<< "cardToDraw = "<< cardToDraw<< ".\n";//Debugging line.
    drawnCard = deck[cardToDraw];
    deck[cardToDraw] = 0;//Removes the drawn card from the deck.
    return drawnCard;
}

---

This compiles with one warning in Code::Blocks (for me), but repeats cards.

Quote:

---

Originally Posted by tabstop

expected semicolon before curlybrace

---

Are you missing a semicolon?

Yeah that's not legal c++. I'm amazed that it compiles, since even c++0x should not allow assigning to an array.

Also, as salem said, deck needs to be static and initialised.

Code:

---

static int deck[52] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,
8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};

---

You don't need that while loop.

I didn't use that before because I didn't know what static was. I just looked it up and did it, and you're both right. It compiles without any warnings now, and it doesn't repeat any cards. Thanks for your help, everyone. Now I can get started on the actual game.

I don't really understand why the other way isn't legal, though. Doesn't this way assign to the array too, just in the same line as it's declared?

No, it initializes the array. It looks similar, but there is a formal difference. Some things can only be initialized but not assigned, like arrays and const variables. There's also a difference with classes concerning which functions are called.

Sorry if this is off-topic, but is there a way to efficiently check the sum of each value in an array without manually adding deck[1] + deck[2] + deck[3] etc., and a way to force a static variable to reset to its original value? I would like to add a line in the loop that chooses a card to check the sum, and if it's 0 it should reset the array. This would prevent infinite loops and reset the deck if it runs out of cards.

Quote:

---

Originally Posted by wipeout4wh

Sorry if this is off-topic, but is there a way to efficiently check the sum of each value in an array without manually adding deck[1] + deck[2] + deck[3] etc., and a way to force a static variable to reset to its original value? I would like to add a line in the loop that chooses a card to check the sum, and if it's 0 it should reset the array. This would prevent infinite loops and reset the deck if it runs out of cards.

---

No and No. You'd need to loop through the whole array or keep a running total.

Quote:

---

Originally Posted by King Mir

No and No. You'd need to loop through the whole array or keep a running total.

---

So there's no way to reset the deck? How would I make it possible to continue playing after the deck runs out of cards, and prevent the infinite loop?

Like I said originally, you shuffle the deck before you start dealing.

Shuffle: to arrange in a random order; pick two random card positions, and swap them over; repeat a number of times.

Deal: take the next card from the deck; all you need to do here is keep a count of how many cards you've dealt.

Quote:

---

Originally Posted by Salem

Like I said originally, you shuffle the deck before you start dealing.

Shuffle: to arrange in a random order; pick two random card positions, and swap them over; repeat a number of times.

Deal: take the next card from the deck; all you need to do here is keep a count of how many cards you've dealt.

---

But that still doesn't solve the problem of getting a new, partially full deck (not including the cards that are in play) when every card is gone. Drawing a random card is pretty much the equivalent of drawing from a shuffled deck, so it makes shuffling pointless.

You can get a new shuffled deck by shuffling the deck again and reseting the next card pointer/index to the beginning.

Quote:

---

Originally Posted by King Mir

You can get a new shuffled deck by shuffling the deck again and reseting the next card pointer/index to the beginning.

---

I don't know anything about pointers yet, so I don't know what any of that means. I still don't see why shuffling is necessary, either.

Code:

---

if ( numCardsDealt == 52 ) {
  // reshuffle the deck
  numCardsDealt = 0;
}

---

> I still don't see why shuffling is necessary, either.
Have you ever played blackjack with a deck of real cards?

Try to model the actions you take there.

People do not pick random numbers up to 52, and then check to see if that card has already been drawn.

No, they randomise the order to begin with, and then sequentially draw cards from the top.

Shuffeling is a more standard solution, and eliminates the need to repopulate the array. You can do it your way, but then you'll need to write a function to repopulate the deck. Also, as a lesser point if you use a shuffled deck, you automatically have the number of cards played.

Quote:

---

Originally Posted by Salem

Code:

---

if ( numCardsDealt == 52 ) {
  // reshuffle the deck
  numCardsDealt = 0;
}

---

> I still don't see why shuffling is necessary, either.
Have you ever played blackjack with a deck of real cards?

Try to model the actions you take there.

People do not pick random numbers up to 52, and then check to see if that card has already been drawn.

No, they randomise the order to begin with, and then sequentially draw cards from the top.

---

I guess, but drawing a random card is easier, and it accomplishes the same task in the long run. Is there really any benefit besides making the game's programming more realistic?

Quote:

---

Originally Posted by King Mir

Shuffeling is a more standard solution, and eliminates the need to repopulate the array. You can do it your way, but then you'll need to write a function to repopulate the deck. Also, as a lesser point if you use a shuffled deck, you automatically have the number of cards played.

---

How would it eliminate the need to repopulate the array? I would have to send the cards that are no longer in play to a discard pile array, then bring them back to the deck when it's reshuffled.

Edit: Also, I could get the number of cards played by using a static int and adding 1 to it each time drawCard() is called.

You can just have an index to the current point in the deck. Every time you draw a card, you return the card at that index, and increment it by 1.

Quote:

---

Originally Posted by wipeout4wh

I guess, but drawing a random card is easier, and it accomplishes the same task in the long run. Is there really any benefit besides making the game's programming more realistic?

---

The best reason is probably complexity. To get the 52nd card, you'll need to loop a worst case of 52 times, whereas with a shuffled deck, you don't need to loop at all.

Quote:

---

Originally Posted by King Mir

You can just have an index to the current point in the deck. Every time you draw a card, you return the card at that index, and increment it by 1.

---

The index is just the part of an array that's in square brackets, right?

If I do that, it would still reuse the cards that are still in play when I reshuffle the deck. If I have a 5 in my hand, there should only be 3 5's in the deck when it gets reshuffled. That means I would need to remove the card from the deck and add it to a discard pile when it's out of play.

Edit: I decided to have it shuffle the deck first like you guys said. Here's drawCard() so far:

Code:

---

int drawCard() {

    static int deck[52] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
    static int cardToDraw = 0;
    int drawnCard;

    if (cardToDraw < 52) {
        drawnCard = deck[cardToDraw];
        deck[cardToDraw] = 0;
        cardToDraw++;
    }
    else {
        shuffleDeck();
        cardToDraw = 0;
    }

    cout<< "cardToDraw = "<< cardToDraw<< ".\n";//Debugging line.
    return drawnCard;
}

---

I'll have to learn about passing variables between functions, and I haven't written shuffleDeck() yet, but does this look good so far?

Edit: Would it be better to just set deck[52] as a global variable? I don't really understand how to pass variables between functions. I wrote part of shuffleDeck(), but I can't continue until I figure this out.

Code:

---

void shuffleDeck() {

    int firstCard;
    int secondCard;
    int i;

    for (i = 0; i < 100; i++){
        firstCard = (rand() % 52);
        secondCard = (rand() % 52);
       
    }
}

---

Quote:

---

Originally Posted by wipeout4wh

The index is just the part of an array that's in square brackets, right?

If I do that, it would still reuse the cards that are still in play when I reshuffle the deck. If I have a 5 in my hand, there should only be 3 5's in the deck when it gets reshuffled. That means I would need to remove the card from the deck and add it to a discard pile when it's out of play.

---

So reshuffle not when you reach the last card, but when you don't have enough cards to play a full hand. It would not be fair to reshuffle in the middle of a hand.

Quote:

---

Edit: I decided to have it shuffle the deck first like you guys said. Here's drawCard() so far:

Code:

---

int drawCard() {

    static int deck[52] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};
    static int cardToDraw = 0;
    int drawnCard;

    if (cardToDraw < 52) {
        drawnCard = deck[cardToDraw];
        deck[cardToDraw] = 0;
        cardToDraw++;
    }
    else {
        shuffleDeck();
        cardToDraw = 0;
    }

    cout<< "cardToDraw = "<< cardToDraw<< ".\n";//Debugging line.
    return drawnCard;
}

---

I'll have to learn about passing variables between functions, and I haven't written shuffleDeck() yet, but does this look good so far?

Edit: Would it be better to just set deck[52] as a global variable? I don't really understand how to pass variables between functions. I wrote part of shuffleDeck(), but I can't continue until I figure this out.

Code:

---

void shuffleDeck() {

    int firstCard;
    int secondCard;
    int i;

    for (i = 0; i < 100; i++){
        firstCard = (rand() % 52);
        secondCard = (rand() % 52);
       
    }
}

---

---

I wish you knew pointers, because then I could tell you about std::random_shuffle().

The first like of shuffleDeck should look like this. Because deck is an array, modifying it in shuffleDeck will modify it in the original.

Code:

---

void shuffleDeck(int deck[52])

---

To call it simply do:

Code:

---

shuffleDeck(deck)

---

Also, you don't need to make your first card random, as long as your second card is. then you can loop from 0 to 52 (i<52), and know that every card has been swapped at least once.

I've learned a little about pointers, but I still don't completely understand why they are useful. I'll change my shuffling function to loop 52 times instead of 500. The code I posted only loops 100 times, but I changed it to loop 500 times just to be sure. I guess that's a little overkill if 52 loops is enough.

In this case a pointer would function as a iterator for an array. Often you need to access a specific element in a container like an array, such as when you loop through each element. With arrays, this can be done using the array name, plus the index, but this is not efficient for all containers. Even for arrays, using pointers can be faster. So instead the standard template library, which provides containers and common algorithms like random_shuffle(), relies on iterators to access elements. And for primitive arrays, a pointer functions as an iterator.

Pointers also provide a null-able pass by reference capability. One result of this is that is that pointers and smart pointers are used to signify ownership of heap variables.

Yeah... I didn't really understand that.

Quote:

---

Originally Posted by King Mir

The first like of shuffleDeck should look like this. Because deck is an array, modifying it in shuffleDeck will modify it in the original.

Code:

---

void shuffleDeck(int deck[52])

---

To call it simply do:

Code:

---

shuffleDeck(deck)

---

---

So shuffleDeck() should use deck as a parameter? I made deck a global variable, so shuffleDeck() can access it even if it's not a parameter. Do I still need to do that?

Edit: I've made quite a bit of progress, but I still haven't started writing the actual game.

Code:

---

#include <iostream>
#include <cmath>
#include <ctime>
#include <cstdlib>

using namespace std;

int drawCard();
void shuffleDeck(int deck[54]);
void game();

static int deck[52] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13};

    //The main function includes pre-game stuff and instructions.
int main() {

    time_t now;//Sets now to equal the current time.
    time(&now);
    srand(now);//Uses the current time as the seed for random numbers.

    char viewInstructions;

    cout<< "Welcome to Blackjack.\nWould you like to view the instructions? (Y/N)\n";

    do {
        cin>> viewInstructions;
        cin.ignore();

        switch(toupper(viewInstructions)) {
            case 'Y':
                cout<< "Select an option by typing its letter.\nPress enter when you are ready to play.\n";
                cin.get();
                game();
                break;
            case 'N':
                game();
                break;
            default:
                cout<< "Syntax error. Please type Y or N, then press enter.\n";
        }
    }while (viewInstructions != 'y' || 'Y' || 'n' || 'N');

    return 0;
}

    //This function starts the game.
void game() {
    int playerHand[5];
    int dealerHand[5];

    cout<< "game is running";//DEBUG
}

    //This function draws a new card.
int drawCard() {

    static int cardToDraw = 0;
    int drawnCard;

    if (cardToDraw < 52) {//If there are cards left in the deck, draw one.
        drawnCard = deck[cardToDraw];
        deck[cardToDraw] = 0;//Removes the card from the deck.
        cardToDraw++;//Next time the function is called, it will draw the next card.
    }
    else {//If there are no cards in the deck, shuffle the deck.
        shuffleDeck(deck);
        cardToDraw = 0;//Draw deck[0] next time the function is called.
    }

    cout<< "cardToDraw = "<< cardToDraw<< ".\n";//Debugging line.
    return drawnCard;
}


    //This function shuffles the deck.
void shuffleDeck(int deck[54]) {

    int cardToSwap;//This is the card that will be swapped with the first card.
    int temp;//This is used to temporarily store the value of deck[cardToSwap]
    int i;

    for (i = 0; i < 52; i++){//Loops through each card, swapping it with a random card from the deck.
        cardToSwap = (rand() % 52);
        temp = deck[cardToSwap];
        deck[i] = deck[cardToSwap];
        deck[cardToSwap] = temp;
    }
}

---

I'm having some trouble getting the instruction do/while loop in main to work. For one thing, it displays the instructions no matter what I type. It also doesn't end after it calls the game function. It just waits for input from the user, then keeps waiting for more input if any is given.

I do plan to expand the instructions. I just didn't feel like typing out a guide to Blackjack, so I used that as a placeholder.

Edit: Would it be better to use a switch for the instructions?

Edit: I changed it to a switch, and it's working good (it doesn't show the instructions if I type n or N). It still continues to wait for input instead of ending the program, though. Could that just be because I haven't written game() yet? I updated the code above to the version with the switch.

Explaining how pointers are used in one shorts post is limiting.

You should avoid global variables. You should avoid static variables too, for that matter, and instead declare deck in main.

"(viewInstructions != 'y' || 'Y' || 'n' || 'N')"

This doesn't do what you think it does. It checks viewInstructions != 'y', then if 'Y' !=0, then 'n' !=0, then 'N'!=0.

Quote:

---

Originally Posted by King Mir

Explaining how pointers are used in one shorts post is limiting.

You should avoid global variables. You should avoid static variables too, for that matter, and instead declare deck in main.

"(viewInstructions != 'y' || 'Y' || 'n' || 'N')"

This doesn't do what you think it does. It checks viewInstructions != 'y', then if 'Y' !=0, then 'n' !=0, then 'N'!=0.

---

Why should I avoid static and global variables? Isn't it kind of necessary to use them sometimes?

I did manage to fix my do/while loop before you posted that, but I didn't mention it.

Code:

---

do {
        cin>> viewInstructions;
        cin.ignore();

        switch(toupper(viewInstructions)) {
            case 'Y':
                cout<< "Select an option by typing its letter.\nPress enter when you are ready to play.\n";
                cin.get();
                viewInstructions = 'N';//If this is not set to 'N', the do/while will continue to loop.
                game();
                break;
            case 'N':
                game();
                break;
            default:
                cout<< "Syntax error. Please type Y or N, then press enter.\n";
        }
    }while ((toupper(viewInstructions)) != 'N');

---

I kind of feel like setting viewInstructions to 'N' in case 'Y' is an awkward solution, but it does work.

There are times when global variables are the best solution, but usually they are not. One disadvantage here is the re-usability and versatility of the drawCard function. It can only draw cards from the global deck. Another is that it's harder to track what functions modify deck. This makes debugging harder.


You can use ||, you just have to put compare viewInstructions to every letter explicitly.

I had to use && instead of ||.

Code:

---

    do {
        cin>> viewInstructions;
        cin.ignore();

        switch(toupper(viewInstructions)) {
            case 'Y':
                cout<< "Select an option by typing its letter.\nPress enter when you are ready to play.\n";
                cin.get();
                game();
                break;
            case 'N':
                game();
                break;
            default:
                cout<< "Syntax error. Please type Y or N, then press enter.\n";
        }
    } while ((toupper(viewInstructions)) != 'N' && (toupper(viewInstructions)) != 'Y');

---

If I used ||, it would loop no matter what because it's checking to see if it's unequal to 'Y' or 'N'. It can't be equal to both, so the loop condition will always be true.