在C中将一个结构数组划分为2个单独的数组

Question

我正在制作一副纸牌，但遇到了一个问题。我想将一组（52 张牌）分成两组，每副牌 26 张牌。

我有制作每一个的功能，并将它们显示在屏幕上。我对花色和牌面都使用了枚举。我也在结构内部使用了枚举。

当我按此顺序使用函数时一切正常（代码如下）：

1. Deck_Creator
2. Deck_Shuffler
3. Deck1_Creator（洗好的主牌组的前 26 张牌正在进入牌组 1）
4. Display_Hand1（显示牌组 1 - 52 张牌组中的前 26 张牌，工作正常）
5. Deck2_Creator（洗牌后的第二张 26 张牌）
6. Display_Hand2（工作正常）。

然后在第 7 步中我想显示Deck1，但在使用Deck2_Creator 之后，一切都搞砸了。我的甲板 1，突然看起来像甲板 2，移动了 1 个位置到数组的末尾，deck1[0] 是来自 deck1 的最后一个值。

我尝试将数据从主卡座复制到deck1/deck2，并使用memcpy，但我不知道我还能做什么。如果您看到一种更好、更简单的方法将一副牌一分为二，我很想听听。

---

划分后我想做一个队列，用来制作纸牌游戏“战争”：每个人翻转一张纸牌，然后比较纸牌，排名最高的获胜。

这是我的代码：

#define SIZE 52
#define HALF_SIZE 26

using namespace std; // i can use only cin, and cout from c++

typedef enum Suit { Diamonds, Hearts, Spades, Clubs } Suit_t;
typedef enum Power { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace } Power_t;

typedef struct card {
    Suit_t suit;
    Power_t power;
}cards;

void Deck_Creator(cards* deck) {            // WORKS FINE
    for (int i = 0; i < SIZE; i++) {
        deck[i].suit = (Suit)(i / 13);
        deck[i].power = (Power)(i % 13);
    }
}

void Display_Deck(cards* deck) {           // WORKS FINE
    for (int i = 0; i < SIZE; i++) {
        if (deck[i].suit == 0) {
            cout << "Diamond ";
        }
        else if (deck[i].suit == 1) {
            cout << "Heart ";
        }
        else if (deck[i].suit == 2) {
            cout << "Spade ";
        }
        else {
            cout << "Club ";
        }
        cout << " " << deck[i].power << endl;
        cout << endl;
    }
}

void Deck_Shuffler(cards* deck) {
    int changer = 0;               // Index of changed card
    cards temp = {};             // Temporary holding place for changing
    srand(time(NULL));            // Function to get random numbers with current time
    for (int i = 0; i < SIZE; i++) {
        changer = rand() % SIZE;   // Generating random number from 0 to 51
        temp = deck[i];
        deck[i] = deck[changer];
        deck[changer] = temp;
    }
}

void Display_Hand_1(cards* deck1) {   // WORKS ONLY WITH PREVIOUS Deck1_Creator function

    for (int i = 0; i < 26; i++) {
        cout << deck1[i].suit;
        cout << " " << deck1[i].power;
        cout << endl;
    }
}

void Display_Hand_2(cards* deck2) {    // WORKS ONLY WITH PREVIOUS Deck2_Creator function

    for (int i = HALF_SIZE; i < SIZE; i++) {
        cout << deck2[i].suit;
        cout << " " << deck2[i].power << " ";
        cout << endl;
    }
}

void Deck1_Creator(cards* deck, cards* deck1) {
    for (int i = 0; i < HALF_SIZE; i++) {
        memcpy(&deck1[i], &deck[i], sizeof(cards));
    }

}

void Deck2_Creator(cards* deck, cards* deck2) {
    int i = HALF_SIZE;
    for (; i < SIZE; i++) {
        deck2[i] = deck[i];   // Simple copying struct array content into another array
    }

}

int main() {                  
    cards deck[SIZE];
    cards deck1[HALF_SIZE];
    cards deck2[HALF_SIZE];
    char choice;

    for(; ;) {  //Never ending loop
        cin >> choice;
        switch (choice) {
        case '1':
            cout << endl << "Unshuffled deck: " << endl;
            Deck_Creator(deck);
            Display_Deck(deck);
            break;
        case '2':
            cout << endl << "Shuffled deck: " << endl;
            Deck_Shuffler(deck);
            Display_Deck(deck);
            break;
        case '3':
            cout << endl << "Hand 1:" << endl;
            Deck1_Creator(deck, deck1);
            Display_Hand_1(deck1);
            break;
        case '4':
            cout << endl << "Hand 2:" << endl;
            Deck2_Creator(deck, deck2);
            Display_Hand_2(deck2);
            break;
        case '5':
        //  Deck1_Creator(deck, deck1);
            Display_Hand_1(deck1);
            break;
        case '6':
            Display_Hand_2(deck2);
            break;
        }
    }
    return 0;
}

Answer 1

在Deck2_Creator 中，您将复制到deck2[HALF_SIZE] 以后，但deck2 只是HALF_SIZE 元素的开头长度，因此这些分配超出了范围。你可能想像这样复制到deck2[0]：

void Deck2_Creator(cards* deck, cards* deck2) {
    for (int i = 0; i < HALF_SIZE; i++) {
        deck2[i] = deck[i + HALF_SIZE];
    }
}