How do I check if a variable is of a certain type (compare two types) in C?

Question

In C (not C++/C#) how do I check if a variable is of a certain type?

For example, something like this:

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

Or more general: How do I compare two types so that compare(double1,double2) will evaluate to true, and compare(int,double) will evaluate to false. Also I'd like to compare structs of different composition as well.

Basically, I have a function that operates on variables of type "struct a" and "struct b". I want to do one thing with the "struct a" variables and the other with the "struct b" variables. Since C doesn't support overloading and the void pointer losses its type information I need to check for type. BTW, what would be the sense in having a typeof operator, if you can't compare types?

The sizeof method seems to be a practical workaround solution for me. Thanks for your help. I still find it a bit strange since the types are known at compile time, but if I imagine the processes in the machine I can see, why the information is not stored in terms of types, but rather in terms of byte size. Size is the only thing really relevant besides addresses.

Can't you cast both of them to a double (and add `0.00`)? Not sure if this is possible in C, just a suggestion. — Kevin, Jun 08 '11 at 14:13
Look in the source code, it states right there that doubleVar is a double. No need(and not possible either) to check it at runtime. — Habalusa, Jun 08 '11 at 14:13
In response to Edit #1: have you considered using function pointers (like a vtable) to solve your issue? — Michael Foukarakis, Jun 08 '11 at 16:07
If you like the sizeof methode, read [that article](http://carolina.mff.cuni.cz/~trmac/blog/2005/the-ugliest-c-feature-tgmathh/) about the tgmath implementation of gcc. — quinmars, Jun 08 '11 at 21:01

score 74 · Accepted Answer · edited Nov 29 '20 at 08:36

Getting the type of a variable is, as of now, possible in C11 with the _Generic generic selection. It works at compile-time.

The syntax is a bit like that for switch. Here's a sample (from this answer):

    #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")

To actually use it for compile-time manual type checking, you can define an enum with all of the types you expect, something like this:

    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
    };

And then use _Generic to match types to this 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)

bdonlan · Answer 2 · 2015-10-20T05:47:00.917

27

C does not support this form of type introspection. What you are asking is not possible in C (at least without compiler-specific extensions; it would be possible in C++, however).

In general, with C you're expected to know the types of your variable. Since every function has concrete types for its parameters (except for varargs, I suppose), you don't need to check in the function body. The only remaining case I can see is in a macro body, and, well, C macros aren't really all that powerful.

Further, note that C does not retain any type information into runtime. This means that, even if, hypothetically, there was a type comparison extension, it would only work properly when the types are known at compile time (ie, it wouldn't work to test whether two void * point to the same type of data).

As for typeof: First, typeof is a GCC extension. It is not a standard part of C. It's typically used to write macros that only evaluate their arguments once, eg (from the GCC manual):

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

The typeof keyword lets the macro define a local temporary to save the values of its arguments, allowing them to be evaluated only once.

In short, C does not support overloading; you'll just have to make a func_a(struct a *) and func_b(struct b *), and call the correct one. Alternately, you could make your own introspection system:

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) );
  }
}

You must, of course, remember to initialize the header properly when creating these objects.

edited Oct 20 '15 at 05:47

answered Jun 08 '11 at 14:12

bdonlan

224,562
31
268
324

2

Not even a workaround or clever trick with macros or something? – con-f-use Jun 08 '11 at 14:17
2

@con-f-use, why do you need this? – bdonlan Jun 08 '11 at 14:17
@con-f-use Macros work at compile-time. They know just as much as you do when you are writing the code. – cnicutar Jun 08 '11 at 14:18
@cnicutar I know what a macro is. Thanks! @bdonlan I almost feel bad not accepting your answer. The sizeof idea was simply a better workaround for me. +10 for you my friend and thanks a lot. – con-f-use Jun 08 '11 at 14:36
5

@con-f-use, it's a great workaround until you add a member, the sizes become equal, and suddenly it's always taking the `struct a` branch, even if it's a `struct b`. :) – bdonlan Jun 08 '11 at 14:38
yes I'm aware of the problems that might occur and will be careful. The other methodes are cleaner, but this gives me much less sweat. – con-f-use Jun 08 '11 at 21:52
@bdonlan, *"First, `typeof` is a GCC extension"*... wait, what's wrong with GCC extensions? Does it not roll well? – Pacerier Mar 06 '15 at 11:09
@Pacerier: they don't roll well if your aim is to ever build your code with another compiler. – Oliver Charlesworth Mar 06 '15 at 12:41
@OliverCharlesworth, So which compiler are you using? Why would you ever want to use another compiler besides GCC? – Pacerier Mar 08 '15 at 13:40
@Pacerier: I assume that's a joke? – Oliver Charlesworth Mar 08 '15 at 13:56
Let's say I want to rite a function which sums 2 numbers which can be `single` or `double`. How can I do that? I know it can be single function. But can I create a wrapper which determines the type and call the appropriate one? Thank You. – Royi Aug 07 '17 at 18:18

score 13 · Answer 3 · edited Mar 06 '15 at 11:07

13

As other people have already said this isn't supported in the C language. You could however check the size of a variable using the sizeof() function. This may help you determine if two variables can store the same type of data.

Before you do that, read the comments below.

edited Mar 06 '15 at 11:07

Pacerier

86,231
106
366
634

answered Jun 08 '11 at 14:27

Steve Walsh

6,363
12
42
54

5

To add to that, if you insist on doing this, add a static assert to ensure the sizes never become the same accidentally: `struct STATIC_ASSERT_size_not_equal_s { char STATIC_ASSERT_size_not_equal[sizeof(a) == sizeof(b) ? -1 : 1]; };` – bdonlan Jun 08 '11 at 14:36
In my case of comparing structs they both have the same members except for one having two additional double member. So I should be save if I do "if(sizeof(a)>sizeof(b))" independent of architecture or other stuff. Thanks anyways. – con-f-use Jun 08 '11 at 14:47
5

"You could however check the size of a variable using the sizeof() function" `sizeof (int) == sizeof (float)` , but they have completely different storage format. – phoxis Jun 08 '11 at 15:26

score 9 · Answer 4 · answered Nov 25 '15 at 11:44

Gnu GCC has a builtin function for comparing types __builtin_types_compatible_p.

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

This built-in function returns 1 if the unqualified versions of the types type1 and type2 (which are types, not expressions) are compatible, 0 otherwise. The result of this built-in function can be used in integer constant expressions.

This built-in function ignores top level qualifiers (e.g., const, volatile). For example, int is equivalent to const int.

Used in your example:

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

score 7 · Answer 5 · answered Apr 16 '18 at 04:23

As another answer mentioned, you can now do this in C11 with _Generic.

For example, here's a macro that will check if some input is compatible with another type:

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

You can use the macro like so:

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
}

This can also be used on other types, including structs. E.g.

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;
}

And on typedefs.

typedef char* string;

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

However, it doesn't always give you the answer you expect. For instance, it can't distinguish between an array and a pointer.

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");
}

Answer borrowed from here: http://www.robertgamble.net/2012/01/c11-generic-selections.html

score 7 · Answer 6 · answered Jun 08 '11 at 14:26

As others have mentioned, you can't extract the type of a variable at runtime. However, you could construct your own "object" and store the type along with it. Then you would be able to check it at runtime:

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

Then set the type as needed in the code:

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

Volodymyr Boiko · Answer 7 · 2018-04-13T09:53:15.483

From 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; \
})

Here you can find explanation which statements from standard and which GNU extensions above code uses.

(Maybe a bit not in scope of the question, since question is not about failure on type mismatch, but anyway, leaving it here).

Daniel Peirano · Answer 8 · 2015-06-08T07:37:18.290

3

This is crazily stupid, but if you use the code:

fprintf("%x", variable)

and you use the -Wall flag while compiling, then gcc will kick out a warning of that it expects an argument of 'unsigned int' while the argument is of type '____'. (If this warning doesn't appear, then your variable is of type 'unsigned int'.)

Best of luck!

Edit: As was brought up below, this only applies to compile time. Very helpful when trying to figure out why your pointers aren't behaving, but not very useful if needed during run time.

edited Jun 08 '15 at 07:37

answered Jun 08 '15 at 03:45

Daniel Peirano

514
5
12

Yes but that is not checkable in C and works only at compile-time not at run-time. – con-f-use Jun 08 '15 at 06:26
True. I ran into this question trying to debug some run-away pointer math, so identifying the problem at compile-time addressed my problems. – Daniel Peirano Jun 08 '15 at 07:35

score 1 · Answer 9 · edited Nov 11 '17 at 13:30

C is statically typed language. You can't declare a function which operate on type A or type B, and you can't declare variable which hold type A or type B. Every variable has an explicitly declared and unchangeable type, and you supposed to use this knowledge.

And when you want to know if void * points to memory representation of float or integer - you have to store this information somewhere else. The language is specifically designed not to care if char * points to something stored as int or char.

phicr · Answer 10 · 2023-01-29T20:07:51.637

As of C2x, typeof is now a part of the language's standard. This allows the creation of a macro that compares the types of two values:

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#define sametypeof(A,B) _Generic(A, typeof(B): true, default: false)

int main() {
  if (sametypeof(1, 2)) {
    printf("1 and 2 have the same type.\n");
  } else {
    printf("1 and 2 don't have the same type.\n");
  }
}

(This compiles with the latest experimental version of GCC 13, using the -std=c2x flag)

If you want to compare between two types, you can use the following workaround:

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#define sametype(A,B) _Generic(*((A*)0), B: true, default: false)

int main() {
  if (sametype(void*, nullptr_t)) {
    printf("void* and nullptr_t are the same type.\n");
  } else {
    printf("void* and nullptr_t are not the same type.\n");
  }
}

Although *((A*)0) is not valid code at runtime, the compiler will still be able to deduce its type as A, so it will work in _Generic, as the code itself will not run and will be discarded. (as far as I remember, this trick has worked in every C11 compliant compiler I've used, including Clang and the Tiny C Compiler)

(you also cannot just do (A)0 because 0 cannot be cast to a struct)

score 0 · Answer 11 · answered Mar 22 '22 at 05:49

0

One possible way is to have your variables names prepend your variable definitions with the type information.

Ex: All integers will have i_ All floats will have f_ etc..

The variable name can be got out by the #<variable_name>, This

answered Mar 22 '22 at 05:49

tkv

11
2

score 0 · Answer 12 · edited May 29 '22 at 06:25

0

There is a built-in function in GCC.

Built-in Function: int __builtin_types_compatible_p (type1, type2) You can use the built-in function __builtin_types_compatible_p to determine whether two types are the same.

edited May 29 '22 at 06:25

Suraj Rao

29,388
11
94
103

answered May 29 '22 at 06:11

AngusKu

23
2

quint-flash · Answer 13 · 2022-09-19T09:09:04.437

i've searched a solution to solve the issue of controlling data type for while , and i thought that maybe my founding could add up well with the initial demand @con-f-use, even if it's no exactly the same issue.

An other way around to control the datatype could be done using an union with predefined type. In my case, i had a defined structure in which i was originally using a void* to allow divers data type to be passed : originally:

//[main]: 

uint32_t vtest3= 100000;
int32_t vtest2= 100000;
struct entity list[] = {
  { TYPE_INT32,     s_int32_t,  .label="tension", &vtest3},
  { TYPE_INT32,     s_int32_t,  .label="tension", &vtest3}
};



//[file.h]:


struct entity {
   enum entity_type type;
   uint32_t dimension;
   char* label;
   void* ptr_data;
    uint32_t offset;
};
enum  entity_type {
  TYPE_NONE     = 0,
  TYPE_INT8     = 1,
  TYPE_INT16    = 2,
  TYPE_INT32    = 3,
  TYPE_INT64    = 4,
  TYPE_UINT8    = 5,
  TYPE_UINT16   = 6,
  TYPE_UINT32   = 7,
  TYPE_UINT64   = 8,
  TYPE_FLOAT32  = 9

};

The issue with this method is that it accept all type of variable in an uncontrolled way. There is no easy method to control the data type referenced by the void* pointer, Excepted maybe thought the use of a macro and _Generic as described before in this thread.

If the programmer decided to pass a type different from the list of type accepted ,there while be no error thrown at compile time. . They other way around is by replacing the void* by an union , this way the structure while only accept specific data type defined inside the union list . If the programmer decide to pass a pointer with an type which is not already defined inside the ptr_data union{...} , it will throw an error.

//[file.h]:
enum  entity_type {
  TYPE_NONE     = 0,
  TYPE_INT8     = 1,
  TYPE_INT16    = 2,
  TYPE_INT32    = 3,
  TYPE_INT64    = 4,
  TYPE_UINT8    = 5,
  TYPE_UINT16   = 6,
  TYPE_UINT32   = 7,
  TYPE_UINT64   = 8,
  TYPE_FLOAT32  = 9

};
struct entity {
  enum entity_type type;
  uint32_t dimension;
  char* label;
  union {
    uint8_t *uint8;
    uint16_t *uint16;
    uint32_t *uint32;
    uint32_t *uint;
    int16_t *int16;
    int32_t *int32;
    int64_t *int64;

    float *f;
  } ptr_data;

  uint32_t offset;
};

[main:]

uint32_t vtest3= 100000;
int32_t vtest2= 100000;

struct entity list[] = {
{ TYPE_INT32,   s_int32_t,  .label="a", .ptr_data = {.uint16=&vtest1}
},
{ TYPE_INT32,   s_int32_t,  .label="b", .ptr_data = {.int32=&vtest2}
};

This method make use of the union to control implicitly the data type of the variable inserted by the programmer in the structure. If not correct the compiler while throw an error at compile time.

Obviously this code example is far from perfect and cannot be used directly but i tried to explain in a way as clear as possible the logic and the the idea that i proposed ;)

How do I check if a variable is of a certain type (compare two types) in C?

13 Answers13

Linked