C ++二十一点功能

Question

I've started teaching myself C++ and have been trying to write a blackjack program. I'm trying to use classes to represent the cards, deck, and hands. I believe everything is working in the program so far except the dealCardToHand() method.

void dealCardToHand(deck& d, hand& h){
    h.setCard(h.getCardsInHand(), d.dealCard());
    h.setCardsInHand(h.getCardsInHand() + 1);
}

It seems to correctly increment the number of cards in the hand but does not call the setCard() method with the correct data. Any help would be appreciated. I'm including the relevant classes and methods:

class deck{
    int topCard;
    card * cards[52];
 public:
     deck();
     void shuffle();
     void printDeck();
     card dealCard();
};

card deck::dealCard(){//returns top card of deck and increments top card one
    return *cards[topCard++];
}

class hand{
    card * handCards[12];
    int cardsInHand;
public:
    hand();
    card getCard(int i){ return *handCards[i]; }
    void setCard(int i, card c) { handCards[i] = &c; }
    int getCardsInHand() { return cardsInHand; }
    void setCardsInHand(int i) { cardsInHand = i; }
    void printHand();
};

Answer 1

This is dangerous (and probably at least part of your problem):

void setCard(int i, card c) {handCards[i]=&c;}

Here, setCard(...) is passed a card object by value. This means that a new copy of the caller's card is created in temporary location. It is this copy ( c ) which setCard() acts on. By setting handCards[i]=&c; , you save the location of this temporary object. But when setCard() returns, that temporary object is no longer valid.

But then you go on to dereference handCards[i] in getCard() . This yields undefined behavior. In theory, you should expect demons to start flying out of your nose. In practice, you will see total garbage returned from getCard() . Or a crash. Or maybe, if you're sufficiently unlucky, the last value passed into setCard() .

On the whole, it looks like you're playing fast and loose with pointers. I'd suggest one of two ways to resolve the problem:

1. Use pointers everywhere, never pass or return by value. This will probably lead to other issues, but they might not be quite so mysterious.
2. Use pointers nowhere. Pass and return everything by value.

Of course those aren't the only options, but they might make your life easier for the time being.

Answer 2

As others have noted, the issue is that you're storing the address of a temporary variable in a pointer variable and dereference that pointer variable after the temporary has gone out of scope (and has been deleted).

Allow my answer to move a bit more into the abstract:

In C++, we distinguish between value classes and polymorphic classes. You will find them under different names, and you will also find classes where the distinction between the two is not as sharp as one would like, but it roughly goes like this:

1. Value class instances differ from each other in their state. If the state of two instances is equal, the behaviour of the instances will be equal, too.

   Examples of value classes are std::string , all STL containers, std::complex<> , etc.

   You use them as you would use int s: you create them on the stack:

    std::string s = "Hello, World"; // NOT std::string * s = new std::string; 

   aggregate them by value:

    class Widget { std::complex<double> m_value; // NOT std::complex<double> * m_value; public: // ... }; 

   you can usually compare them for equality, copy them around, store them in containers:

    std::vector<std::string> vec; std::string s = "Hello, World"; assert( s == "Hello, World" ); vec.push_back( s ); 

   and, most relevant to your question, you pass them around by (const-)reference (or by value, esp. if they're very small), and you return them by value, too:

    void func(const std::vector<double> & vec); // ok, just reading 'vec' void func(std::vector<double> & vec); // ok, possibly writing to 'vec' void func(std::vector<double> vec); // not so good, expensive in C++03; ok in C++11 in some situations std::vector<double> func(); // ok, return value optimisation (look it up!) will make this fast 

2. Polymorphic classes differ in behaviour, not state. Two instances of a polymorphic class may have the same state, yet still behave completely different. Polymorphic classes may also differ in their state, but the focus is on their behaviour. This is what OOP (object-oriented programming) is all about.

   Borrowing example classes from the well-known C++ library "Qt", a QLineEdit and a QPushButton are both QWidget s. They may have the same state (size, position, ...), yet what happens when you click into each with the mouse is completely different between them.

   In C++, to use polymorphic behaviour, you must call virtual functions, and you must do so through a pointer or reference to a common base class ( QWidget in the above). Therefore, polymorphic classes are usually allocated on the heap:

    QLineEdit * le = new QLineEdit(); QPushButton * pb = new QPushButton(); QWidget * leAsWidget = le; // works QWidget * pbAsWidget = pb; // works 

   and stored and passed around in (smart) pointer variables:

    class MyWidget : public QWidget { QLineEdit * m_lineEdit; QPointer<QPushButton> m_pushButton; // QPointer is a smart pointer public: // ... }; 

For your program, you have to decide whether you need deck and hand to be polymorphic or not.

If yes, create them on the heap (with new ), store and pass them around by pointer, and don't forget to delete them again when you're done with them (or have a look at smart pointer).

If no, give them relational operators ( bool operator==(const deck &lhs, const deck &rhs) , ...), copy semantics ( deck(const deck&) , deck &operator=(const deck&) ), create them on the stack and store them by value. Pass them around by (const) reference. You don't need to delete them, the compiler will do that for you.