C 中的类型检查宏参数

Question

是否可以对#define 宏的参数进行类型检查？例如：

typedef enum
{
    REG16_A,
    REG16_B,
    REG16_C
}REG16;

#define read_16(reg16)  read_register_16u(reg16); \
                        assert(typeof(reg16)==typeof(REG16));

上面的代码似乎不起作用。我做错了什么？

顺便说一句，我正在使用 gcc，我可以保证在这个项目中我将始终使用 gcc。代码不需要是可移植的。

Answer 1

不，宏不能为您提供任何类型检查。但是，毕竟，为什么要宏？您可以编写一个 static inline 函数，该函数（可能）将被编译器内联 - 在这里您将进行类型检查。

static inline void read_16(REG16 reg16) {
    read_register_16u(reg16);
}

Answer 2

要继续 ulidtko 的想法，请使用 inline 函数并让它返回一些内容：

inline
bool isREG16(REG16 x) {
  return true;
}

有了这样的事情你可以做编译时断言：

typedef char testit[sizeof(isREG16(yourVariable))];

Answer 3

没有。 C 中的宏本质上是类型不安全的，尝试检查 C 中的类型充满了问题。

首先，在没有可用类型信息的编译阶段通过文本替换来扩展宏。因此，编译器在进行宏扩展时完全不可能检查参数的类型。

其次，当您尝试在扩展代码中执行检查时，例如问题中的 assert，您的检查将推迟到运行时，并且还会触发看似无害的构造，例如

a = read_16(REG16_A);

因为枚举数（REG16_A、REG16_B 和 REG16_C）属于int 类型，而不是REG16 类型。

如果您想要类型安全，最好的办法是使用函数。如果您的编译器支持它，您可以声明函数inline，这样编译器就知道您希望尽可能避免函数调用开销。

Answer 4

gcc 支持 typeof

例如取自 linux 内核的 typesafe min 宏

#define min(x,y) ({ \
    typeof(x) _x = (x); \
    typeof(y) _y = (y); \
    (void) (&_x == &_y);        \
    _x < _y ? _x : _y; })

但它不允许您比较两种类型。请注意，虽然指针比较会产生警告 - 您可以像这样进行类型检查（也来自 linux 内核）

#define typecheck(type,x) \
({  type __dummy; \
    typeof(x) __dummy2; \
    (void)(&__dummy == &__dummy2); \
    1; \
})

大概你可以做类似的事情 - 即比较指向参数的指针。

Answer 5

对于与整数相关的类型，C 中的类型检查有点松散；但是你可以利用大多数指针类型不兼容的事实来欺骗编译器。

所以

#define CHECK_TYPE(var,type) { __typeof(var) *__tmp; __tmp = (type *)NULL; }

如果类型不同，这将给出警告，“来自不兼容的指针类型的赋值”。例如

typedef enum { A1,B1,C1 } my_enum_t;
int main (int argc, char *argv) {
    my_enum_t x;
    int y;

    CHECK_TYPE(x,my_enum_t);  // passes silently
    CHECK_TYPE(y,my_enum_t);  // assignment from incompatible pointer type
}

我确信有某种方法可以得到编译器错误。

Answer 6

这是一个老问题，但我相信我有一个一般性的答案，根据Compiler Explorer 似乎可以在 MSVC、gcc 和 clang 上工作。

#define CHECK_TYPE(type,var) { typedef void (*type_t)(type); type_t tmp = (type_t)0; if(0) tmp(var);}

在每种情况下，如果类型不兼容，编译器都会生成有用的错误消息。这是因为它强加了用于函数参数的相同类型检查规则。

它甚至可以在同一范围内多次使用而不会出现问题。这部分让我有些吃惊。 （我认为我必须利用“__LINE__”来获得这种行为）

下面是我运行的完整测试，注释掉的行都会产生错误。

#include <stdio.h>

#define CHECK_TYPE(type,var) { typedef void (*type_t)(type); type_t tmp = (type_t)0; if(0) tmp(var);}

typedef struct test_struct
{
    char data;
} test_t;

typedef struct test2_struct
{
    char data;
} test2_t;

typedef enum states
{
    STATE0,
    STATE1
} states_t;

int main(int argc, char ** argv)
{
    test_t * var = NULL;
    int i;
    states_t s;
    float f;

    CHECK_TYPE(void *, var);  //will pass for any pointer type
    CHECK_TYPE(test_t *, var);
    //CHECK_TYPE(int, var);
    //CHECK_TYPE(int *, var);
    //CHECK_TYPE(test2_t, var);
    //CHECK_TYPE(test2_t *, var);
    //CHECK_TYPE(states_t, var);

    CHECK_TYPE(int, i);  
    //CHECK_TYPE(void *, i);  

    CHECK_TYPE(int, s);  //int can be implicitly used instead of enum
    //CHECK_TYPE(void *, s);  
    CHECK_TYPE(float, s); //MSVC warning only, gcc and clang allow promotion
    //CHECK_TYPE(float *, s);

    CHECK_TYPE(float, f); 
    //CHECK_TYPE(states_t, f);

    printf("hello world\r\n");
}

在每种情况下，带有 -O1 及更高版本的编译器都会删除结果代码中宏的所有痕迹。

使用 -O0 MSVC 将对函数的调用保留为零，但它在无条件跳转中被敲击，这意味着这不应该是一个问题。带有 -O0 的 gcc 和 clang 都删除了除了 tmp 变量的堆栈初始化为零之外的所有内容。

Answer 7

在Zachary Vander Klippe 的answer 的基础上，我们甚至可以更进一步（以一种可移植的方式，尽管这不是必需的）并且另外确保传入类型的大小匹配使用通常用于在 C 中实现静态断言的“负数组长度”技巧传入的变量的大小（当然，在 C11 之前，它确实提供了新的 _Static_assert 关键字）。

作为一个额外的好处，让我们加入一些const 兼容性。

#define CHECK_TYPE(type,var) \
  do {\
    typedef void (*type_t) (const type);\
    type_t tmp = (type_t)(NULL);\
    typedef char sizes[((sizeof (type) == sizeof (var)) * 2) - 1];\
    if (0) {\
      const sizes tmp2;\
      (void) tmp2;\
      tmp (var);\
    }\
  } while (0)

将新的 typedef 引用为名为 tmp2 的变量（此外，还引用此变量）只是一种确保我们不会生成不必要的警告的方法，参见 -Wunused-local-typedefs 和喜欢。我们可以改用__attribute__ ((unused))，但那是不可移植的。

这将解决原始示例中的整数提升“问题”。

本着同样精神的例子，失败的陈述被注释掉：

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

#define CHECK_TYPE(type,var) \
  do {\
    typedef void (*type_t) (const type);\
    type_t tmp = (type_t)(NULL);\
    typedef char sizes[((sizeof (type) == sizeof (var)) * 2) - 1];\
    if (0) {\
      const sizes tmp2;\
      (void) tmp2;\
      tmp (var);\
    }\
  } while (0)

int main (int argc, char **argv) {
    long long int ll;
    char c;

    //CHECK_TYPE(char, ll);
    //CHECK_TYPE(long long int, c);
   
    printf("hello world\n");

    return EXIT_SUCCESS);
}

当然，即使这种方法也无法解决所有问题。例如，检查符号很困难，并且通常依赖于假设正在使用特定补码变体（例如，二进制补码）的技巧，因此不能通用。如果类型可以是结构，那就更不用说了。