Как сделать определения типа структуры видимыми вне объединения C ++

Question

Я получаю следующие ошибки при компиляции под g ++ (это сегменты гораздо более длинного кода)

---

ошибка: недопустимое использование неполного типа 'const struct cmp_bk (const void *, const void *) :: bk'

ошибка: предварительное объявление 'const struct cmp_bk (const void *, const void *) :: bk'

Код выглядит следующим образом:

static union {
    struct tt {                     /* Transposition table entry */
            unsigned short hash;    /* - Identifies position */
            short move;             /* - Best recorded move */
            short score;            /* - Score */
            char flag;              /* - How to interpret score */
            char depth;             /* - Remaining search depth */
    } tt[CORE];
    struct bk {                     /* Opening book entry */
            unsigned long hash;     /* - Identifies position */
            short move;             /* - Move for this position */
            unsigned short count;   /* - Frequency */
    } bk[CORE];
} core;

Позже в программе мы определяем новые структуры a, b

static int cmp_bk(const void *ap, const void *bp)
{
    const struct bk *a = (bk*) ap;
    const struct bk *b = (bk*) bp;

    if (a->hash < b->hash) return -1;
    if (a->hash > b->hash) return 1;
    return (int)a->move - (int)b->move;

}

Возможно, у нас (?) Возникли проблемы с доступом к struct bk за пределами объединения

Answer 1

Это плохая попытка компилировать код C как C ++. Вы не можете определить тип внутри анонимного типа и ожидать, что сможете получить к нему доступ. Итак, код после исправления это

struct tt_type {                     /* Transposition table entry */
    unsigned short hash;    /* - Identifies position */
    short move;             /* - Best recorded move */
    short score;            /* - Score */
    char flag;              /* - How to interpret score */
    char depth;             /* - Remaining search depth */
};

struct bk_type {                     /* Opening book entry */
    unsigned long hash;     /* - Identifies position */
    short move;             /* - Move for this position */
    unsigned short count;   /* - Frequency */
};

static union {
    tt_type tt[CORE];
    bk_type bk[CORE];
} core;

static int cmp_bk(const void *ap, const void *bp)
{
    const bk_type *a = (const bk_type*) ap;
    const bk_type *b = (const bk_type*) bp;

    if (a->hash < b->hash) return -1;
    if (a->hash > b->hash) return 1;
    return (int)a->move - (int)b->move;
}

Теперь давайте перейдем к тому, что это не код C ++. Прежде всего, эти структуры громоздки в использовании - по крайней мере, добавьте конструкторы. Во-вторых, профсоюзы не очень безопасны для типов - вместо этого используйте boost::variant. В-третьих, cmp_bk. Сделай это operator==(const bk_type&, const bk_type&) - без указателей, без void*, без глупого литья. В-четвертых, массивы фиксированного размера - почти всегда плохая идея, вызывающая всевозможные проблемы. Вместо этого используйте std::vector. И сейчас у меня заканчиваются точки здравомыслия, поэтому я закончу.

Answer 2

Вы можете просто объявить структуры вне объединения:

struct tt {                     /* Transposition table entry */
        unsigned short hash;    /* - Identifies position */
        short move;             /* - Best recorded move */
        short score;            /* - Score */
        char flag;              /* - How to interpret score */
        char depth;             /* - Remaining search depth */
};
struct bk {                     /* Opening book entry */
        unsigned long hash;     /* - Identifies position */
        short move;             /* - Move for this position */
        unsigned short count;   /* - Frequency */
};

static union {
    struct tt tt[CORE];
    struct bk bk[CORE];
} core;