Random shuffle inquiry

Question

Making a poker game, doing basics now created a vector struct with my values, shuffling it, and then printing out 5 "cards". My problem is that when I press "2" to deal again, it gives me same cards. I simply just want it to grab ANOTHER 5 cards from my array and keep doing so until there is not enough cards to deal again, and then for it to reshuffle and continue. Here's what I have so far, and it does what I said, it shuffles and then prints out 5 different cards, but if I press deal again I get the same 5 cards unless I shuffle again.

#include <iostream>
#include <vector>
#include <algorithm>
#include "stdio.h"
#include "stdlib.h"
#include "ctime"
#include "cstdlib"
using namespace std;

struct node
{
    int number;
    string suit;
    struct node *info;
};

vector<node> deckArray();
void displayDeal();
void Start();
vector<node> Deck(52);

int main()
{
    Start();
}

void Start()
{
    int choice;
    int choice2;

    deckArray();
    Deck.push_back(node());

    for (int s = 0; s < 2; ++s)
        Deck[0].number = s;
    while (1)
    {
        printf("1. Shuffle.\n");
        printf("2. Deal.\n");
        printf("2. Exit.");
        cin >> choice;

        switch (choice)
        {
            case 1:
                printf("\nAdding a hand!\n");
                deckArray();
                //Shuffle(Deck);
                break;
            case 2:
                for (int i = 0; i < 5; ++i)
                {
                    printf("\n%d", Deck[i].number);
                    printf("%s\n", Deck[i].suit.c_str());
                }
                cin.get();
                break;
            case 3:
                exit(1);
            default:
                printf("\n Invalid Choice. \n");
                break;
        }
    }
}

vector<node> deckArray()
{
    Deck[0].number = 2;
    Deck[0].suit = "S";
    Deck[1].number = 2;
    Deck[1].suit = "H";
    Deck[2].number = 2;
    Deck[2].suit = "D";
    Deck[3].number = 2;
    Deck[3].suit = "C";
    //2
    Deck[4].number = 3;
    Deck[4].suit = "S";
    Deck[5].number = 3;
    Deck[5].suit = "H";
    Deck[6].number = 3;
    Deck[6].suit = "D";
    Deck[7].number = 3;
    Deck[7].suit = "C";
    //3
    Deck[8].number = 4;
    Deck[8].suit = "S";
    Deck[9].number = 4;
    Deck[9].suit = "H";
    Deck[10].number = 4;
    Deck[10].suit = "D";
    Deck[11].number = 4;
    Deck[11].suit = "C";
    //4
    Deck[12].number = 5;
    Deck[12].suit = "D";
    Deck[13].number = 5;
    Deck[13].suit = "C";
    Deck[14].number = 5;
    Deck[14].suit = "D";
    Deck[15].number = 5;
    Deck[15].suit = "C";
    //5
    Deck[16].number = 6;
    Deck[16].suit = "D";
    Deck[17].number = 6;
    Deck[17].suit = "C";
    Deck[18].number = 6;
    Deck[18].suit = "D";
    Deck[19].number = 6;
    Deck[19].suit = "C";
    //6
    Deck[20].number = 7;
    Deck[20].suit = "D";
    Deck[21].number = 7;
    Deck[21].suit = "C";
    Deck[22].number = 7;
    Deck[22].suit = "D";
    Deck[23].number = 7;
    Deck[23].suit = "C";
    //7
    Deck[24].number = 8;
    Deck[24].suit = "D";
    Deck[25].number = 8;
    Deck[25].suit = "C";
    Deck[26].number = 8;
    Deck[26].suit = "D";
    Deck[27].number = 8;
    Deck[27].suit = "C";
    //8
    Deck[28].number = 9;
    Deck[28].suit = "D";
    Deck[29].number = 9;
    Deck[29].suit = "C";
    Deck[30].number = 9;
    Deck[30].suit = "D";
    Deck[31].number = 9;
    Deck[31].suit = "C";
    //9
    Deck[32].number = 10;
    Deck[32].suit = "D";
    Deck[33].number = 10;
    Deck[33].suit = "C";
    Deck[34].number = 10;
    Deck[34].suit = "D";
    Deck[35].number = 10;
    Deck[35].suit = "C";
    //10
    Deck[36].number = 11; //need to convert to string "J"
    Deck[36].suit = "D";
    Deck[37].number = 11;
    Deck[37].suit = "C";
    Deck[38].number = 11;
    Deck[38].suit = "D";
    Deck[39].number = 11;
    Deck[39].suit = "C";
    //11 (J)
    Deck[40].number = 12; //need to convert to string "Q"
    Deck[40].suit = "D";
    Deck[41].number = 12;
    Deck[41].suit = "C";
    Deck[42].number = 12;
    Deck[42].suit = "D";
    Deck[43].number = 12;
    Deck[43].suit = "C";
    //12 (Q)
    Deck[44].number = 13; //need to convert to string "K"
    Deck[44].suit = "D";
    Deck[45].number = 13;
    Deck[45].suit = "C";
    Deck[46].number = 13;
    Deck[46].suit = "D";
    Deck[47].number = 13;
    Deck[47].suit = "C";
    //13 (K)
    Deck[48].number = 14; //need to convert to string "A"
    Deck[48].suit = "D";
    Deck[49].number = 14;
    Deck[49].suit = "C";
    Deck[50].number = 14;
    Deck[50].suit = "D";
    Deck[51].number = 14;
    Deck[51].suit = "C";

    random_shuffle(Deck.begin(), Deck.end());
    return Deck;
}

1 solution to my problem, however not sure if this is a programmer no-no or not

case 2:
    addToShuffle();
    break;

void addToShuffle()
{
for (int i = x; i < z; ++i)
{
    printf("\n%d", Deck[i].number);
    printf("%s\n", Deck[i].suit.c_str());
}
x += 5;
z += 5;
cin.get();
}

Answer 1

case 2 just prints the first 5 cards, without removing them from the deck... So dealing a new time (without shuffle) will still return the same cards.

[OT] deckArray may be rewritten as follow:

vector<node> deckArray()
{
    vector<node> cards(52);
    const char* colors[4] = {"S", "H", "D", "C"};

    int i = 0;
    for (int v = 2; v != 15; ++v) {
        for (int c = 0; c != 4; ++c, ++i) {
            cards[i].number = v;
            cards[i].suit = colors[c];
        }
    }
    random_shuffle(cards.begin(), cards.end());
    return cards;
}

Answer 2

At the moment, you only ever deal cards 0-4 from the vector. If you don't change the vector between deals, then those elements will always be the same. There are two obvious ways to fix that.

Probably the best approach is to keep track of how many cards you've already dealt, and start there on the next deal. For example, the first time it will start dealing from 0, and store somewhere that the next available card is at index 5. The second time, it will start dealing from 5, and so on.

An alternative approach is to pop each card from the vector as you deal it (and optionally add it to a second 'discard' vector). That way, the deck will get smaller every time you deal, until there are no cards left. That approach is easier in some ways, but it means you'd have to resize and repopulate the deck every time you shuffle it.