Как сделать gcc предупреждением о передаче неправильного перечисления функции

Ответ 1

Причиной такого поведения является то, что вы используете компилятор C, а не С++. И в C типы перечислений на самом деле не являются типами, перечисления в C просто удерживают int-константы, и их можно свободно смешивать с любыми целыми числами и любой арифметикой.

В С++ вместо этого у вас есть реальные перечисления, как вы хотели бы их обдумать, и необходимая проверка типов происходит в соответствии с языковым стандартом.

Ваша проблема может быть решена двумя способами:

• Использовать компилятор С++.

  Таким образом, у вас будут реальные перечисления, как вы того захотите.

• Измените свой код на чистый стиль C, т.е. не используя перечисления, так как на C они являются просто постоянными наборами, где компилятор только помогает вам заказывать постоянные значения. И в C вы будете ответственны за сохранение "типов" прошедших констант. Еще раз: для C перечисляющие члены являются просто int-константами, вы не можете заставить их печатать.

#define REG8_A 0
#define REG8_B 1
#define REG8_C 2

#define REG16_A 0
#define REG16_B 1
#define REG16_C 2

Ответ 2

Единственный способ, с помощью которого я могу создать предупреждение, - это если вы готовы передать указатели, а не голые перечисления, например

typedef enum
{
    REG8_A,
    REG8_B,
    REG8_C
} REG8;

typedef enum
{
    REG16_A,
    REG16_B,
    REG16_C
} REG16;

void function(REG8 * reg8)
{

}

int main(void)
{
    REG16 r = REG16_A;
    function(&r);
    return 0;
}

Не совсем элегантное решение, но оно дает предупреждение, по крайней мере, с gcc -Wall:

$ gcc -Wall warn_enum.c -o warn_enum
warn_enum.c: In function ‘main’:
warn_enum.c:23: warning: passing argument 1 of ‘function’ from incompatible pointer type
$

Ответ 3

Для того, чтобы сделать это в C, используя GCC -Wenum-compare (который включен по умолчанию, если вы включаете -Wall), вы должны выполнить сравнение по константе перечисления, прежде чем передавать его функции, чтобы получить требуемую диагностику.

-Wenum-сравнить

Предупреждать о сравнении значений разных перечислимых типов. В С++ также диагностируются просчеты в условных выражениях, и предупреждение включен по умолчанию. В C это предупреждение включено -Wall.

http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html

Для такого сравнения случается автоматически, когда мы вызываем функцию, мы можем обернуть функцию в макрос. Для удобства чтения я также определяю макрос SAFE_ENUM, который выполняет безвредное сравнение константы перечисления (это то, что в конечном итоге вызывает предупреждение при попытке передать неправильную константу перечисления на foo или bar).

/**
  SAFE_ENUM: evaluate an enumeration constant safely
  TYPE: the enumeration type
  VAL: the enumeration constant to evaluate
*/
#define SAFE_ENUM(TYPE, VAL) ((VAL) == (TYPE)0 ? (VAL) : (VAL))

typedef enum
{
    REG8_DEFAULT,
    REG8_A,
    REG8_B,
    REG8_C
} Reg8;

typedef enum
{
    REG16_DEFAULT,
    REG16_A,
    REG16_B,
    REG16_C
} Reg16;

void foo(Reg8 reg8)
#define foo(reg8) foo(SAFE_ENUM(Reg8, reg8))
{
    printf("%s called with value %d\n", __func__, reg8);
}

void bar(Reg16 reg16)
#define bar(reg16) bar(SAFE_ENUM(Reg16, reg16))
{
    printf("%s called with value %d\n", __func__, reg16);
}

int main(void)
{
    foo(REG8_A);  // ok
    bar(REG16_A); // ok
    foo(REG16_B); // warning
    bar(REG8_B);  // warning

    Reg16 a_reg16 = 42;
    foo(a_reg16); // warning: foo requires a Reg8 but you gave it a Reg16
}

Ответ 4

Как указывали другие, C не проводит различия между перечисленным типом и основным типом. (Некоторые компиляторы могут включать проверку типов для enum или typedef в качестве расширений; YMMV.)

Чтобы получить проверку типов на C, вы можете использовать struct s, но затем вы теряете использование встроенных операторов сравнения и возможность switch для переменной. Вы можете попробовать что-то вроде этого:

typedef struct {
    enum {
        reg8_val_A,
        reg8_val_B,
        reg8_val_C,
    } val;
} reg8;
#define reg8_A (reg8){.val = reg8_val_A}
#define reg8_B (reg8){.val = reg8_val_B}
#define reg8_C (reg8){.val = reg8_val_C}
…
bool
is_A_or_B(reg8 reg) {
    if reg.val == reg8_A.val    // one way to compare
        return true;
    switch (reg.val) {
        case reg8_val_B:        // the other way to compare; note that
            return true;        // "case reg8_B.val:" will *not* work
        case reg8_val_C:
            return false;
        default:
            fprintf(stderr, "bad reg value %d\n", reg.val);
            abort();
    }
}

(Использует некоторые функции C99.)

Ответ 5

$ g++ test3.cpp -o test3
test3.cpp: In function ‘int main()’:
test3.cpp:22: error: cannot convert ‘REG16’ to ‘REG8’ for argument ‘1’ to ‘void function(REG8)’

Ответ 6

С GCC 4.6 вы должны использовать опции -Wconversion и -Werror для предотвращения любых неявных преобразований типов. Это приводит к ошибке с кодом, опубликованным Paul R. Но исходный код компилируется в любом случае. Я не знаю, почему.