C 控制台游戏-Eclipse CDT 调试和发布是不同的

Question

我使用 Eclipse CDT 用 C 语言创建了一个简单的控制台 BlackJack 游戏。我有一个奇怪的问题，运行 eclipse 生成的 DEBUG 可执行文件，程序运行正常，如图所示:

-------
PLAYERS
-------
Player-1: (18) [ eight:spade, king:heart ]
>> (H)it/(C)heck: c

------
DEALER
------
Dealer: (21) [ king:diamond, ace:diamond ]

-------
RESULTS
-------
Player-1: Loss - 18 under dealer's 21.

但是，当我将 Eclipse 切换为构建 RELEASE 而不是 DEBUG 时，生成的可执行文件如下:

-------
PLAYERS
-------
Player-1: (4) [ four:(null), (null):(null) ]
>> (H)it/(C)heck: h
Player-1: (4) [ four:(null), (null):(null), (null):(null) ]
>> (H)it/(C)heck: h
Player-1: (4) [ four:(null), (null):(null), (null):(null), (null):(null) ]
>> (H)it/(C)heck: c

------
DEALER
------
Dealer: (0) [ (null):(null), (null):(null) ]
Dealer: (0) [ (null):(null), (null):(null), (null):(null) ]
Dealer: (0) [ (null):(null), (null):(null), (null):(null), (null):(null) ]
...
...

我希望这更多是 Eclipse/CDT/Build 问题，但如果您需要查看源代码，请告诉我。我没有发布源代码，因为大约有 15 个以上的文件。

预先感谢您的帮助。

编辑:添加源代码。

卡片.h

#ifndef CARD_H_
#define CARD_H_

/* The various ranks of a Card. */
enum Rank {
    ACE,
    TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN,
    JACK, QUEEN, KING
};

/* The various suits of a Card. */
enum Suit {
    CLUB, DIAMOND, HEART, SPADE
};

/* A structure which defines a Card. */
struct Card {
    enum Rank rank;
    enum Suit suit;
};

/*
 * Each possible Card rank contains two possible values. This structure can
 * be used to contain the two values.
 */
struct CardValue {
    int value1;
    int value2;
};

/* Creates a Card with a suit and a rank. */
struct Card create_card(const enum Rank rank, const enum Suit suit);

/* Takes a Rank enum and provides a string representation. */
char* rank_to_string(const enum Rank rank);

/*
 * Takes a Rank enum and provides a structure containing the rank's possible
 * values. Each Rank has two possible values, as the Ace is both 1 and 11.
 */
struct CardValue rank_to_value(const enum Rank rank);

/* Takes a Suit enum and provides a string representation. */
char* suit_to_string(const enum Suit suit);

/* Takes a Card structure and outputs its members as a string. */
char* card_to_string(const struct Card card);

#endif /* CARD_H_ */

卡片.c

#include "card.h"
#include <stdio.h>
#include <stdlib.h>

struct Card create_card(const enum Rank rank, const enum Suit suit)
{
    struct Card card;
    card.rank = rank;
    card.suit = suit;
    return card;
}

char* rank_to_string(const enum Rank rank)
{
    switch (rank) {
        case ACE: return "ace";
        case TWO: return "two";
        case THREE: return "three";
        case FOUR: return "four";
        case FIVE: return "five";
        case SIX: return "six";
        case SEVEN: return "seven";
        case EIGHT: return "eight";
        case NINE: return "nine";
        case TEN: return "ten";
        case JACK: return "jack";
        case QUEEN: return "queen";
        case KING: return "king";
    }
    return 0;
}

struct CardValue rank_to_value(const enum Rank rank)
{
    struct CardValue card_value;
    switch (rank) {
        case ACE:
            card_value.value1 = 1;
            card_value.value2 = 11;
            break;
        case TWO:
            card_value.value1 = 2;
            card_value.value2 = 2;
            break;
        case THREE:
            card_value.value1 = 3;
            card_value.value2 = 3;
            break;
        case FOUR:
            card_value.value1 = 4;
            card_value.value2 = 4;
            break;
        case FIVE:
            card_value.value1 = 5;
            card_value.value2 = 5;
            break;
        case SIX:
            card_value.value1 = 6;
            card_value.value2 = 6;
            break;
        case SEVEN:
            card_value.value1 = 7;
            card_value.value2 = 7;
            break;
        case EIGHT:
            card_value.value1 = 8;
            card_value.value2 = 8;
            break;
        case NINE:
            card_value.value1 = 9;
            card_value.value2 = 9;
            break;
        case TEN:
        case JACK:
        case QUEEN:
        case KING:
            card_value.value1 = 10;
            card_value.value2 = 10;
            break;
        default:
            card_value.value1 = 0;
            card_value.value2 = 0;
    }
    return card_value;
}

char* suit_to_string(const enum Suit suit)
{
    switch (suit) {
        case CLUB: return "club";
        case DIAMOND: return "diamond";
        case HEART: return "heart";
        case SPADE: return "spade";
    }
    return 0;
}

char* card_to_string(const struct Card card)
{
    size_t buffer_size = 15;
    char* output = malloc(sizeof(char) * buffer_size);
    snprintf(output, sizeof(char) * buffer_size, "%s:%s",
            rank_to_string(card.rank), suit_to_string(card.suit));
    return output;
}

手.h

#ifndef HAND_H_
#define HAND_H_

#define BUSTED 21
#define MAX_HAND_SIZE 22

/*
 * Creates a structure representing a Hand of Cards. The 'cards' member is
 * an array of cards within the hand, and the 'index' member is the location
 * of the last inserted card.
 */
struct Hand {
    struct Card* cards;
    int index;
};

/* Creates a structure for a Hand of cards. */
struct Hand create_hand();

/* Adds a Card to a Hand. */
void add_card_to_hand(struct Hand* hand, const struct Card card);

/*
 * Finds the highest possible, non-busted value for a Hand of cards. If the
 * Hand is busted, the value will be greater than 21.
 */
int hand_to_value(const struct Hand hand);

/* A String representation of a Hand of cards. */
char* hand_to_string(const struct Hand hand);

#endif /* HAND_H_ */

手.c

#include "hand.h"
#include "card.h"
#include <stdlib.h>
#include <string.h>

struct Hand create_hand()
{
    struct Hand hand;
    hand.cards = malloc(sizeof(struct Card) * MAX_HAND_SIZE);
    hand.index = 0;
    return hand;
}

void add_card_to_hand(struct Hand* hand, const struct Card card)
{
    /*
     * The 'index' member of the structure contains the incremented location
     * of the last inserted card.
     */
    hand->cards[hand->index] = card;
    hand->index++;
}

int hand_to_value(const struct Hand hand)
{
    /* Create a structure which holds the possible value combinations. */
    struct CardValue hand_value;
    hand_value.value1 = 0;
    hand_value.value2 = 0;

    /* Loop through each card in the hand and sum the possible totals. */
    int i;
    for (i = 0; i < hand.index; i++) {
        struct Card card = hand.cards[i];
        struct CardValue card_value = rank_to_value(card.rank);
        hand_value.value1 += card_value.value1;
        hand_value.value2 += card_value.value2;
    }

    /* If both totals are busted, return the lower of the 2. */
    if (hand_value.value1 > BUSTED && hand_value.value2 > BUSTED) {
        if (hand_value.value1 < hand_value.value2) {
            return hand_value.value1;
        } else {
            return hand_value.value2;
        }
    /* If the first total is busted, return the second total. */
    } else if (hand_value.value1 > BUSTED) {
        return hand_value.value2;
    /* If the second total is busted, return the first total. */
    } else if (hand_value.value2 > BUSTED) {
        return hand_value.value1;
    /* No totals are busted, return the highest of the two. */
    } else if (hand_value.value1 >= hand_value.value2) {
        return hand_value.value1;
    } else if (hand_value.value1 < hand_value.value2) {
        return hand_value.value2;
    }
    return 0;
}

char* hand_to_string(const struct Hand hand)
{
    /* Allocate memory for a string representation of the Hand. */
    size_t buffer_size = 500;
    char* output = malloc(sizeof(char) * buffer_size);
    memset(output, 0, buffer_size);

    /*
     * Concatenate the string representations of the cards to the string
     * representation of the Hand.
     */
    int i;
    strcat(output, "[ ");
    for (i = 0; i < hand.index; i++) {
        struct Card card = hand.cards[i];
        char* card_string = card_to_string(card);
        strcat(output, card_string);
        free(card_string);
        if (i + 1 < hand.index) {
            strcat(output, ", ");
        }
    }
    strcat(output, " ]\n");
    return output;
}

甲板.h

#ifndef DECK_H_
#define DECK_H_

#define DECK_SIZE 52

/*
 * Creates a structure representing a Deck of Cards. The 'cards' member is
 * an array of cards within the deck, and the 'iterator' member is the location
 * of the last accessed card.
 */
struct Deck {
    struct Card* cards;
    int iterator;
    int number_of_decks;
};

/*
 * Creates a new Deck of cards. The 'number_of_decks' parameter dictates how
 * many 52-card decks will be generated in the Deck.
 */
struct Deck create_deck(const int number_of_decks);

/* Shuffles the cards within the Deck. */
void shuffle_deck(struct Deck* deck);

/*
 * Returns the next Card structure in the Deck, or NULL if the iterator has
 * reached the end of the Deck.
 */
struct Card* deck_next_card(struct Deck* deck);

#endif /* DECK_H_ */

甲板.c

#include "deck.h"
#include "card.h"
#include <time.h>
#include <stddef.h>
#include <stdlib.h>

struct Deck create_deck(const int number_of_decks)
{
    /*
     * Allocate memory for a deck of cards, ensuring that the size of a deck,
     * as well as the number of decks are considered.
     */
    struct Deck deck;
    deck.iterator = 0;
    deck.number_of_decks = number_of_decks;
    int total_number_of_cards = (DECK_SIZE * number_of_decks);
    deck.cards = malloc(sizeof(struct Card) * total_number_of_cards);

    /*
     * For the amount of decks requested, create a card with each possible
     * rank and suit combination and add them to the deck. The loop_index will
     * be used to access each array member for the deck.
     */
    int deck_index;
    int suit_index;
    int rank_index;
    int loop_index = 0;
    for (deck_index = 0; deck_index < number_of_decks; deck_index++) {
        for (suit_index = CLUB; suit_index <= SPADE; suit_index++) {
            for (rank_index = ACE; rank_index <= KING; rank_index++) {
                struct Card card = create_card(rank_index, suit_index);
                deck.cards[loop_index] = card;
                loop_index++;
            }
        }
    }
    return deck;
}

void shuffle_deck(struct Deck* deck)
{
    /* Use the current time as the seed to our rand() function. */
    srand(time(0));

    /* Use the 'Fisher-Yates shuffle' algorithm. */
    int i;
    int total_number_of_cards = (DECK_SIZE * deck->number_of_decks);
    for (i = total_number_of_cards - 1; i > 0; i--)
    {
        int j = rand() % (i + 1);
        struct Card temp = deck->cards[j];
        deck->cards[j] = deck->cards[i];
        deck->cards[i] = temp;
    }
}

struct Card* deck_next_card(struct Deck* deck)
{
    /*
     * The 'iterator' member of the Deck contains the last accessed card.
     * Using this variable, we are able to traverse the Deck. If the iterator
     * is greater than the amount of cards there are in the deck, we
     * return NULL.
     */
    struct Card* next_card;
    if (deck->iterator < (DECK_SIZE * deck->number_of_decks)) {
        struct Card card = deck->cards[deck->iterator];
        deck->iterator++;
        next_card = &card;
    } else {
        next_card = NULL;
    }
    return next_card;
}

Answer 1

在阅读我自己的问题时，我偶然发现了答案。

问题出在 deck.c 文件，deck_next_card 函数中。我们可以看到 next_card 变量只在函数范围内赋值，没有被malloc'd。

通过分配自己的内存，它在 RELEASE 内工作:

struct Card* deck_next_card(struct Deck* deck)
{
    /*
     * The 'iterator' member of the Deck contains the last accessed card.
     * Using this variable, we are able to traverse the Deck. If the iterator
     * is greater than the amount of cards there are in the deck, we
     * return NULL.
     */
    struct Card* next_card = malloc(sizeof(struct Card)); # edit 1.
    if (deck->iterator < (DECK_SIZE * deck->number_of_decks)) {
        next_card = &deck->cards[deck->iterator]; # edit 2.
        deck->iterator++;
    } else {
        next_card = NULL;
    }
    return next_card;
}

让我失望的是它在 DEBUG 版本中如何完美地工作，然后在 RELEASE 中却没有。