如何检查C中某个变量是否属于某种类型（比较两种类型）？

在C（不是C ++ / C＃）中，如何检查变量是否为某种类型？

例如，如下所示：

double doubleVar;
if( typeof(doubleVar) == double ) {
    printf("doubleVar is of type double!");
}

或更笼统：我如何比较两种类型，以便compare(double1,double2)评估为true，而compare(int,double)评估为false。我也想比较不同组成的结构。

基本上，我有一个对类型“ struct a”和“ struct b”的变量进行操作的函数。我想用“ struct a”变量做一件事，而用“ struct b”变量做另一件事。由于C不支持重载，并且void指针丢失了其类型信息，因此我需要检查类型。顺便说一句，typeof如果您不能比较类型，那么拥有运算符会有什么意义？

sizeof方法对我来说似乎是一种实际的解决方法。谢谢你的帮助。我仍然发现它有点奇怪，因为类型是在编译时就知道的，但是如果我能想象我可以看到机器中的进程，为什么信息不是按类型存储，而是按字节大小存储。大小是唯一真正有意义的，除了地址。

到目前为止，在C11中使用_Generic通用选择即可获取变量的类型。它在编译时起作用。

语法有点像switch。这是一个示例（来自此答案）：

    #define typename(x) _Generic((x),                                                 \
            _Bool: "_Bool",                  unsigned char: "unsigned char",          \
             char: "char",                     signed char: "signed char",            \
        short int: "short int",         unsigned short int: "unsigned short int",     \
              int: "int",                     unsigned int: "unsigned int",           \
         long int: "long int",           unsigned long int: "unsigned long int",      \
    long long int: "long long int", unsigned long long int: "unsigned long long int", \
            float: "float",                         double: "double",                 \
      long double: "long double",                   char *: "pointer to char",        \
           void *: "pointer to void",                int *: "pointer to int",         \
          default: "other")

要将其实际用于编译时手动类型检查，您可以定义enum具有所有期望类型的，如下所示：

    enum t_typename {
        TYPENAME_BOOL,
        TYPENAME_UNSIGNED_CHAR,
        TYPENAME_CHAR,
        TYPENAME_SIGNED_CHAR,
        TYPENAME_SHORT_INT,
        TYPENAME_UNSIGNED_CHORT_INT,
        TYPENAME_INT,
        /* ... */
        TYPENAME_POINTER_TO_INT,
        TYPENAME_OTHER
    };

然后使用_Generic来匹配类型enum：

    #define typename(x) _Generic((x),                                                       \
            _Bool: TYPENAME_BOOL,           unsigned char: TYPENAME_UNSIGNED_CHAR,          \
             char: TYPENAME_CHAR,             signed char: TYPENAME_SIGNED_CHAR,            \
        short int: TYPENAME_SHORT_INT, unsigned short int: TYPENAME_UNSIGNED_SHORT_INT,     \
              int: TYPENAME_INT,                     \
        /* ... */                                    \
            int *: TYPENAME_POINTER_TO_INT,          \
          default: TYPENAME_OTHER)

C不支持这种形式的自省形式。您要问的是在C中是不可能的（至少没有编译器特定的扩展；但是在C ++中是可能的）。

通常，使用C，您应该知道变量的类型。由于每个函数的参数都有具体的类型（我想应该是varargs除外），因此您不需要检入函数体。我能看到的唯一剩下的情况是在宏主体中，而且，C宏实际上并没有那么强大。

此外，请注意，C不会在运行时保留任何类型信息。这意味着，即使假设有类型比较扩展，它也只有在编译时知道类型时才可以正常工作（即，无法测试两个void *指向相同数据类型的数据）。

至于typeof：首先，typeof是一个GCC扩展。它不是C的标准部分。通常用于编写仅对它们的参数进行一次评估的宏，例如（来自GCC手册）：

 #define max(a,b) \
   ({ typeof (a) _a = (a); \
      typeof (b) _b = (b); \
     _a > _b ? _a : _b; })

该typeof关键字让宏定义本地临时保存其参数值，允许他们只计算一次。

简而言之，C不支持重载。您只需制作一个func_a(struct a *)和func_b(struct b *)，然后调用正确的一个即可。或者，您可以建立自己的自省系统：

struct my_header {
  int type;
};

#define TYPE_A 0
#define TYPE_B 1

struct a {
  struct my_header header;
  /* ... */
};

struct b {
  struct my_header header;
  /* ... */
};

void func_a(struct a *p);
void func_b(struct b *p);

void func_switch(struct my_header *head);
#define func(p) func_switch( &(p)->header )

void func_switch(struct my_header *head) {
  switch (head->type) {
    case TYPE_A: func_a((struct a *)head); break;
    case TYPE_B: func_b((struct b *)head); break;
    default: assert( ("UNREACHABLE", 0) );
  }
}

当然，您必须记住在创建这些对象时正确初始化标题。

正如其他人已经说过的那样，C语言不支持此功能。但是，您可以使用sizeof()函数检查变量的大小。这可以帮助您确定两个变量是否可以存储相同类型的数据。

在执行此操作之前，请阅读下面的评论。

正如其他人提到的那样，您无法在运行时提取变量的类型。但是，您可以构造自己的“对象”并将其与类型一起存储。然后，您将可以在运行时检查它：

typedef struct {
   int  type;     // or this could be an enumeration
   union {
      double d;
      int i;
   } u;
} CheesyObject;

然后根据需要在代码中设置类型：

CheesyObject o;
o.type = 1;  // or better as some define, enum value...
o.u.d = 3.14159;

Gnu GCC具有用于比较类型的内置功能__builtin_types_compatible_p。

https://gcc.gnu.org/onlinedocs/gcc-3.4.5/gcc/Other-Builtins.html

如果类型1和类型2（它们是类型，而不是表达式）的非限定版本兼容，则此内置函数返回1，否则返回0。此内置函数的结果可用于整数常量表达式。

此内置函数忽略顶级限定符（例如const，volatile）。例如，int等同于const int。

在您的示例中使用：

double doubleVar;
if(__builtin_types_compatible_p(typeof(doubleVar), double)) {
    printf("doubleVar is of type double!");
}

从linux / typecheck.h：

/*
 * Check at compile time that something is of a particular type.
 * Always evaluates to 1 so you may use it easily in comparisons.
 */
#define typecheck(type,x) \
({  type __dummy; \
    typeof(x) __dummy2; \
    (void)(&__dummy == &__dummy2); \
    1; \
})

在这里，您可以找到解释说明标准中的哪些语句以及上述代码中使用的GNU扩展。

（也许有点不在问题的范围内，因为问题不是关于类型不匹配的失败，而是无论如何，将其留在这里）。

这是疯狂的愚蠢，但是如果使用代码：

fprintf("%x", variable)

并且在编译时使用-Wall标志，则gcc将发出警告，提示它期望参数为'____'类型的参数为'unsigned int'。（如果未出现此警告，则您的变量的类型为'unsigned int'。）

祝你好运！

编辑： 正如下面提到的，这仅适用于编译时。试图弄清指针为什么不工作时非常有帮助，但在运行时需要时不是很有用。

提到的另一个答案是，您现在可以在C11中使用 _Generic。

例如，这是一个宏，它将检查某些输入是否与另一种类型兼容：

#include <stdbool.h>
#define isCompatible(x, type) _Generic(x, type: true, default: false)

您可以像这样使用宏：

double doubleVar;
if (isCompatible(doubleVar, double)) {
    printf("doubleVar is of type double!\n");  // prints
}

int intVar;
if (isCompatible(intVar, double)) {
    printf("intVar is compatible with double too!\n");  // doesn't print
}

这也可以用于其他类型，包括结构。例如

struct A {
    int x;
    int y;
};

struct B {
    double a;
    double b;
};

int main(void)
{    
    struct A AVar = {4, 2};
    struct B BVar = {4.2, 5.6};

    if (isCompatible(AVar, struct A)) {
        printf("Works on user-defined types!\n");  // prints
    }

    if (isCompatible(BVar, struct A)) {
        printf("And can differentiate between them too!\n");  // doesn't print
    }

    return 0;
}

并在typedef上。

typedef char* string;

string greeting = "Hello world!";
if (isCompatible(greeting, string)) {
    printf("Can check typedefs.\n");
}

但是，它并不总是能给您您所期望的答案。例如，它无法区分数组和指针。

int intArray[] = {4, -9, 42, 3};

if (isCompatible(intArray, int*)) {
    printf("Treats arrays like pointers.\n");
}

// The code below doesn't print, even though you'd think it would
if (isCompatible(intArray, int[4])) {
    printf("But at least this works.\n");
}

从这里借来的答案：http : //www.robertgamble.net/2012/01/c11-generic-selections.html

C是静态类型的语言。您不能声明一个对类型A或类型B进行操作的函数，也不能声明包含类型A或类型B的变量。每个变量都有一个显式声明的且不可更改的类型，因此您应该使用此知识。

当您想知道void *是否指向float或integer的内存表示形式时-您必须将此信息存储在其他位置。该语言经过专门设计，不关心char *是否指向存储为int或char的对象。

为此，我为此编写了一个简单的C程序。它位于github中。GitHub Link

这里是如何工作的...首先将您的double转换为名为s的字符字符串。

char s[50];
sprintf(s,"%.2f", yo);

然后使用我的dtype函数确定类型...我的函数将返回一个字符...您可以像这样使用它...

char type=dtype(s);
//Return types are :
//i for integer
//f for float or decimals
//c for character...

然后您可以使用比较进行检查...就是这样...