Memory leak without allocating any memory?

Question

I'm working on a coding assignment for a C++ class. When I run my program I seem to be dealing with a memory leakage issue, which is weird since I am NOT explicitly allocating any memory in my code. I ran the program under gdb, and it seems as though the program crashes when running the destructor for a Deck object. I tried stepping through the code, but I when I do so I end up in a host of .h files related to vectors. Then suddenly, it stops. I tried going to a TA for some help, but they seem to be as perplexed as I am on the issue.

# include <stdlib.h>
# include <time.h>
# include <iostream>
# include <vector>
# include <stdio.h>

using namespace std;

//function signatures
float bustProbability (const int);


class Deck
{
public:
    //data members
    vector <int> cardArray;
    vector <int> wasteCards;

    //constructor
    Deck();

    //methods
    void shuffleDeck();
    void populateDeckWithCards();
    void removeCopyCards();

    int dealCard();
    int remainingCards();
    void showCards();
};

void Deck::removeCopyCards() {
    for (unsigned int i = 0; i < wasteCards.size(); i++) {
        bool removedCopy = false;
        for (unsigned int j = 0; j < cardArray.size() && removedCopy == false; j++) {
            if (cardArray[j] == wasteCards[i]) {
                cardArray.erase (cardArray.begin() + j - 1);
                removedCopy = true;
            }
        }
    }
}

int Deck::dealCard() {
    if (remainingCards() > 0) {
        int tmp = cardArray.back();
        wasteCards.push_back(tmp);
        cardArray.pop_back();
        return tmp;
    }

    else {
        populateDeckWithCards();
        removeCopyCards();
        shuffleDeck();
        //shuffle method
        int tmp = cardArray.back();
        cardArray.pop_back();
        return tmp;
    }
}

void Deck::populateDeckWithCards() {
    //populate regular cards into array
    for (int i = 2; i <= 10; i++) {
        for (int j = 0; j < 4; j++) {
            cardArray.push_back(i);
        }
    }

    //populate J, Q, K into array
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            cardArray.push_back(10);
        }
    }

    //populating array with Aces... treating them as special case '100'
    for (int i = 0; i < 4; i++) {
        cardArray.push_back(100);
    }

    return;
}

void Deck::showCards() {
    for (unsigned int i = 0; i < cardArray.size(); i++) {
        cout << cardArray[i] << endl;
    }
}

Deck::Deck() {
    wasteCards.clear();
    cardArray.clear();
    populateDeckWithCards();
    shuffleDeck();
}

void Deck::shuffleDeck() {
    int n = cardArray.size();

    for(int a = n-1; a > 0; a--) {
        int min = 0;
        int max = a;
        int j = min + rand() / (RAND_MAX / (max-min + 1) + 1);

        int tmp = cardArray[a];
        cardArray[a] = cardArray[j];
        cardArray[j] = tmp;
    }

    return;
}

int Deck::remainingCards() {
    return cardArray.size();
}


class Player {
public:
    //data members
    vector <int> playerHand;

    //constructor
    Player();

    //methods
    bool isBust();
    int count();
    void hit(Deck&);
    void stand();
    bool muckHand();
    void showHand();
};

Player::Player() {
    playerHand.clear();
}


void Player::showHand() {
    for (unsigned int i = 0; i < playerHand.size(); i++) {
        cout << playerHand[i] << endl;
    }

    return;
}


int Player::count() {
    int handCount = 0;

    for (unsigned int i = 0; i < playerHand.size(); i++) {
        if (playerHand[i] != 100)
            handCount += playerHand[i];

        else {
            if (playerHand[i] == 100) {
                if ((handCount) > 11) {
                    handCount += 1;
                }

                else
                    handCount += 10;
            }
        }
    }

    return handCount;
}

bool Player::isBust() {
    if (count() > 21)
        return true;

    else
        return false;
}

void Player::hit(Deck& d) {
    playerHand.push_back(d.dealCard());
}

void Player::stand() {
    return;
}

bool Player::muckHand() {
    playerHand.clear();
    return true;
}


float bustProbability (const int threshHold) {
    int threshHoldReached = 0;
    Deck myDeck;
    Player myPlayer;
    Player dealer;

    for (int i = 0; i < 10000; i++) {
        myPlayer.hit(myDeck);
        dealer.hit(myDeck);
        myPlayer.hit(myDeck);
        dealer.hit(myDeck);

        while (myPlayer.count() < threshHold) {
            myPlayer.hit(myDeck);
        }

        if (!(myPlayer.isBust())) {
            ++threshHoldReached;
        }

        myDeck.wasteCards.clear();
        myPlayer.muckHand();
        dealer.muckHand();
    }

    float bustFraction = float(threshHoldReached)/float(10000);
    return bustFraction;
}

int main () {
    cout << "blackjack simulation" << endl;
    srand((unsigned int)time(NULL));
    cout << bustProbability(19);

    return 0;
}

I'm incredibly sorry for just posting my code, but I've spend 4 days on this issue, and I can't even begin to figure out what the problem is.

Answer 1

There is at least the line

cardArray.erase (cardArray.begin() + j - 1);

which seems to be dubious in case of j = 0