Poker Hand Program

//Main
#include <iostream>

#include "Hand.h"

int main()
{
    Hand test("2H 3H 4H 5H 6H");

    test.GenerateHandType();

    vector<Card> temp = test.GetHand();

    cout << "Hand: " << endl;

    for(size_t i = 0; i < temp.size(); i++)
    {
        std::cout << temp.at(i).Suit() <<" " <<  temp.at(i).Type() << std::endl;
    }

    std::cout << "Same suit: " << test.HandHasSameSuit() << std::endl;
    std::cout << "Has Pair: " << test.HasPair() << std:: endl;
    std::cout << "Has Multiple Pairs: " << test.HasMultiPair() << std::endl;
    std::cout << "Has Three of a Kind: " << test.HasThreeKind() << std::endl;
    std::cout << "Has Four of a kind: " << test.HasFourKind() << std::endl;
    std::cout << "Has consecutive ranks: " << test.HasConsecRanks() << std::endl;
    std::cout << "Has high consecutive ranks: " << test.HasHighConsecRanks() << std::endl;

    std::cout << std::endl;

    std::cout << "Hand type: " << test.PokerHandType() << endl;
}

//Card
#ifndef CARD_H
#define CARD_H

#include "Utils.h"

class Card
{
private:

    Suits suit;

    CardType type;

public:
    Card()
    {
        suit = NoSuit;
        type = NoType;
    }

    Card(char s, char ct)
    {
        suit = FindSuit(s);
        type = FindType(ct);
    }

    Suits Suit() { return suit; }
    CardType Type() { return type; }

    void SetSuit(Suits s) { suit = s; }
    void SetType(CardType t) { type = t; }
};

#endif

//Hand
#ifndef HAND_H
#define HAND_H

#include <string>
#include <list>
#include <vector>
#include "Card.h"
#include "Utils.h"

using namespace std;

class Hand
{
private:

    static const int NUMCARDS = 5;

    string pokerHandType;

    vector<Card> hand;

    void SetHand(string h)
    {
        int stringIndex = 0;

        Card temp;

        for(int i = 0; i < NUMCARDS; ++i)
        {
            temp.SetType( FindType( h[stringIndex] ) );

            stringIndex++;

            temp.SetSuit( FindSuit( h[stringIndex] ) );

            stringIndex +=2;

            hand.push_back( temp );
        }
    }

    bool bCardsHaveSameSuit;
    bool bHasPair;
    bool bHasMultiplePairs;
    bool bHasThreeKind;
    bool bHasFourKind;

    bool bHasConsecutiveRank;
    //Consecutive rank starting from 10;
    bool bHasHighConsecRank;
    bool bLowestTypeIsTen;

    int numPairs;
private:

    void CheckForSameSuit()
    {
        bCardsHaveSameSuit = hand.at(0).Suit() == hand.at(1).Suit() &&
                                hand.at(0).Suit() == hand.at(2).Suit() &&
                                hand.at(0).Suit() == hand.at(3).Suit() &&
                                hand.at(0).Suit() == hand.at(4).Suit();
    }

    void CheckSameType(vector<Card> h)
    {
        if(h.size() == 0)
        {
            return;
        }

        int numCardsMatching = 1;
        vector<int> matchingIndex;

        matchingIndex.push_back(0);

        for(size_t i = 1; i < h.size(); i++)
        {
            if( h.at(0).Type() == h.at(i).Type() )
            {
                numCardsMatching++;
                matchingIndex.push_back(i);
            }
        }

        if(matchingIndex.size() == 1)
        {
            h.erase( h.begin() );
        }

        if(matchingIndex.size() > 1)
        {
            int i = matchingIndex.size();

            while(i > 0)
            {
                h.erase( h.begin() + matchingIndex.at(i - 1) );
                i--;
            }
        }


        if(numCardsMatching == 2)
        {
            if( bHasPair )
            {
                bHasMultiplePairs = true;
            }
            else
            {
                bHasPair = true;
            }
        }
        else if(numCardsMatching == 3)
        {
            bHasThreeKind = true;
        }
        else if(numCardsMatching == 4)
        {
            bHasFourKind = true;
            return;
        }

        CheckSameType(h);
    }

    void CheckConsecutiveRanks()
    {
        CardType lowestType = FindLowestType();

        if(lowestType == Ten)
        {
            bLowestTypeIsTen = true;
        }

        cout << "Lowest type is ten: " << bLowestTypeIsTen << endl;

        FindConsecRanks(lowestType);

        if(bHasConsecutiveRank && bLowestTypeIsTen)
        {
            bHasHighConsecRank = true;
            bHasConsecutiveRank = false;
        }
    }

    CardType FindLowestType()
    {
        CardType lowestType = NoType;

        for(int i = 0; i < NUMCARDS; i++)
        {
            if(hand.at(i).Type() < lowestType)
            {
                lowestType = hand.at(i).Type();
            }
        }

        return lowestType;
    }

    void FindConsecRanks(CardType type)
    {
        static int cardsChecked = 1;

        if(cardsChecked == 5)
        {
            bHasConsecutiveRank = true;
            return;
        }

        CardType incrementedEnum = (CardType)(1 + (int)type );
        for(int i = 0; i < NUMCARDS; i++)
        {
            if(incrementedEnum == hand.at(i).Type())
            {
                cardsChecked++;
                FindConsecRanks(incrementedEnum);
            }
        }
    }

    void DetermineHandType()
    {
        if( bCardsHaveSameSuit && bHasHighConsecRank )
        {
            pokerHandType = "Royal Flush";
        }
        else if( bCardsHaveSameSuit && bHasConsecutiveRank )
        {
            pokerHandType = "Straight Flush";
        }
        else if( bHasFourKind )
        {
            pokerHandType = "Four of a Kind";
        }
        else if( bHasPair && bHasThreeKind )
        {
            pokerHandType = "Full House";
        }
        else if( bCardsHaveSameSuit )
        {
            pokerHandType = "Flush";
        }
        else if( bHasConsecutiveRank )
        {
            pokerHandType = "Straight";
        }
        else if( bHasThreeKind )
        {
            pokerHandType = "Three of  kind";
        }
        else if( bHasMultiplePairs )
        {
            pokerHandType = "Two Pair";
        }
        else if( bHasPair )
        {
            pokerHandType = "Pair";
        }
        else
        {
            pokerHandType = "High Card";
        }
    }

public:
    Hand(string h)
    {
        SetHand(h);
        pokerHandType = "High Card";
        bCardsHaveSameSuit = false;
        bHasPair = false;
        bHasMultiplePairs = false;
        bHasThreeKind = false;
        bHasFourKind = false;
        bHasConsecutiveRank = false;
        bHasHighConsecRank = false;
        bLowestTypeIsTen = false;
    }

    void Hand::GenerateHandType()
    {
        CheckForSameSuit();
        CheckSameType(hand);
        if( !bHasPair && !bHasMultiplePairs && !bHasThreeKind && !bHasFourKind)
        {
            CheckConsecutiveRanks();
        }
        DetermineHandType();
    }

    vector<Card> GetHand() { return hand; }

    bool HandHasSameSuit() { return bCardsHaveSameSuit; }
    bool HasPair() { return bHasPair; }
    bool HasMultiPair() { return bHasMultiplePairs; }
    bool HasThreeKind() { return bHasThreeKind; }
    bool HasFourKind() { return bHasFourKind; }
    bool HasConsecRanks() { return bHasConsecutiveRank; }
    bool HasHighConsecRanks() { return bHasHighConsecRank; }

    string PokerHandType() { return pokerHandType; }
};

#endif
//Utils
#ifndef UTILS_H
#define UTILS_H

enum Suits
{
    Hearts = 0,
    Diamonds,
    Clubs,
    Spades,
    NoSuit
};

enum CardType
{
    One = 1,
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
    Ace,
    NoType
};


Suits FindSuit(char c)
{
    switch(c)
    {
    case 'H':
        return Hearts;
        break;
    case 'D':
        return Diamonds;
        break;
    case 'C':
        return Clubs;
        break;
    case 'S':
        return Spades;
        break;
    }

    return NoSuit;
}

CardType FindType(char c)
{
    switch(c)
    {
    case 'A':
        return Ace;
        break;
    case '1':
        return One;
        break;
    case '2':
        return Two;
        break;
    case '3':
        return Three;
        break;
    case '4':
        return Four;
        break;
    case '5':
        return Five;
        break;
    case '6':
        return Six;
        break;
    case '7':
        return Seven;
        break;
    case '8':
        return Eight;
        break;
    case '9':
        return Nine;
        break;
    case 'T':
        return Ten;
        break;
    case 'J':
        return Jack;
        break;
    case 'Q':
        return Queen;
        break;
    case 'K':
        return King;
        break;
    }

    return NoType;
}

#endif