Remove the semicolon after class Card;. Thats shouldn't be there, and wont compile.

Quote:
A mutator function for setting the type of card (e.g., A, 2, …)

You dont seem to have this at all. Unless getcard(..) should be named setcard(..) (after all, it wouldn't make much sense to have a getcard function which you have to pass details of the card into).

Quote:
An accessor function that returns the integer value of the card.

void getvalue(int value);

So how exactly is this function going to return the value of the card? And what value are you going to be passing it?

Quote:
A function that returns a Boolean value (true or false) depending on whether the current card object is an ace or not.

bool ace(char face);

Why do you need to pass face into this function? Doesn't the card know what face it is?

This is all pretty basic stuff. If you cant afford a text book try the library, or a google search. Theres tons of introductory information available on the internet.

Alan

I just got done (a month or so ago) doing a text based blackjack game in Java. The two languages are pretty similar, and aside from the interface there's not much in there that couldn't be replicated into C++, so maybe you could get some ideas from that (though please don't plaigerise, this is for school, be honest :-) ).

http://www.aklabs.net/index.php?akp=development&cat=3

The source code and documentation for it are linked to from that page. Feel free to use whatever from that is useful. let me know if it helped you out.

(some explanation of things I did that might help you specifically)

I designed Card objects so that they were objects with a single index (from 0 to the maximum passed to the Deck class's constructor (usually 52), discussed later). This index has various calculations performed on it to return its face value (2, 3, 10, ace, etc), to return its actual index (0-maximum), or to return a string representation of it ("Ace of Hearts" for example).

The Deck was designed as an object containing a Stack object and an ArrayList object (a linked list with random access functions). The constructor was passed a single value, the number of cards you wanted to have in the deck (for the purpose of my game 52 was always passed). New cards from 0-max are created and put into the list; then they are drawn at random and added to the stack, in order to shuffle them, until the list is empty. The deck has functions for combining the pile and shuffling the deck, adding a player's discarded card to the pile, and dealing a new card from the top of the stack.

Hand objects were designed to be able to hold cards, discard cards, and take cards. The only real functions they needed were to take cards, discard cards, and return the values of their totals. I gave the handTotal() function a boolean argument for whether or not you wanted the actual total (e.g., player is showing his cards, or for interal game calculations of bust and such) or just the total of the cards he was showing. Then there was a function to fold the hand (discarding all cards to the pile).

GamePlayer and GameDealer objects are pretty self explanatory. They have a hand each, and they perform blackjack specific operations on those hands. The only difference between the two is that GameDealer doesn't bet or fold and has an AI routine.

The interface on mine is slightly complex and could've been made easier to read, but that class was being written to work, not to be read by others. Enjoy it if you can understand it. :-)

The main game loop, all it really needs to do is grab the input from the user, determine what they want to do, apply that to the rules of the game, and perform the required operations. Or, more appropriately, tell the appropriate objects - the deck, the player, or the dealer - what the player is trying to do, and let them handle it.

Hope this helped out. Good luck

Quote:6. A table class can do the conversion from 1 to Ace when u view the table.

Actually I disagree. Mainly in that you should be checking aces when totaling the player's hand for any reason - whether it's to check for 21/bust, or to compare for winners. Your comparison function needs to be smart enough to know how to use the Ace in the hand, too - using it as a 1 and an 11. I did this by keeping track of how many aces were in the hand while looping through the hand, and then calculating each ace depending on the current total, after I'd done all the other cards.

I also don't agree with using a global constant for setting the size of the deck; this should be passed to the deck as a constructor argument. This way, you can use your deck class again later no matter what game it's in (as some games use decks of different sizes), or at least extend its basic functionality into subclasses (RumDeck, GoFishDeck, etc etc etc). And you can do it without using a global to define a class member's size (which, in my opinion, goes against OO anyways).

I don't really see a need for a Table object, as much as for an interface class that will handle all your update calls generically - paint the screen, update it with the player's cards, etc etc. This'll take the junk of displaying out of your main loop and let it focus on the logic (rules) of the game. The only thing I found that I needed to keep track of related to the table was how many games the player had won at the current table.

// ------------- things I noticed in particular about your code

If you're going to use a Card constructor with no parameters, then you should have a static variable inside the constructor that tells what card comes next in the logical progression. This way you won't break your code by accidentally not providing an argument. (This is a better method anyway, in my opinion - your deck constructor can just keep calling = new Card() on objects up until it reaches the size of the deck and you don't have to worry about your loop counting logic being wrong.)

With your Card class, what I would do is define a constant inside of that class (or global or something) that is an array of faces and values. That's what I did in my game; there were two arrays consisting of the face ("Two", "Three", "Ace", etc) and then the Suit. The modulo of the index by the faces array provides the char representation of the card's face, and index/faces.length provides the suit. This way you only have to store one copy of the faces/suits in memory, and you don't have to pass them to each card; you can have the cards handle their own descriptions and remove yourself from the equation, not to mention use less memory.

You shouldn't really need a function to return whether or not the card is an ace; this should be irrelevant, and if it is relevant it will be obvious if its value is 1 or if its value is 11 and its face is "Ace". (Though a simple distinction between 1 and 11, regardless of the face value, should be sufficient for whatever you're doing with it.) Tell your instructor I said he's overcomplicating things. :-)

Your hand class's requirements don't jive with me. Why does he want you to write two separate functions to do the same thing - take cards? Just write one hit function, and pass it a Card object. If you need to deal the initial two cards, just call it twice. Be sure to pass it a Card object from the Deck, otherwise you run the risk of duplicating cards (the game won't be very true if both players somehow wind up holding the Ace of Spades).

C++ can be a bit confusing at first.

First off, your class methods (functions inside the class) are jacked up. Specifically, the definitions do not match the declarations. Take the following code snippet:



See, your definition and declaration of the Hand constructor is good - it takes no arguments, is public and has no return type. So therefore

Hand::Hand()

is the proper way to begin the definition of the function (the definition being where the actual code lies). However, you've declared deal as a public function that returns an integer, and takes no arguments. However, you've got it defined as a public function of Hand that takes no arguments and returns nothing; this is no good. When the compiler reaches this function, it says "Hey wait a minute - the Hand class doesn't have a member function deal() that doesn't return anything. Let me schmack the programmer." There's other cases in your code where you've not only missed the return type, but you've also missed the argument list. Remember, your function definition needs to look exactly like the function declaration, with the exception of it including the class name and the access modifier. So the syntax is:

 <return type> <class name><access modifier><function name>(<argument list>)

where access modifier is : for private and :: for public. So your function definitions in the above snippet should've looked like this:



There's numerous other errors in your source and violations of coding conventions :-), but this should be enough to get you started. I can send you corrected/commented source files if you want, just let me know.