How I change a variable of a type to another one in C?

Question

I want to do it:

int main () {
  bla bla bla

  void *onetype;

  switch (USER_INPUT_TYPE) {

      CASE CONVERT_TO_CHAR:
          convert onetype VOID TO CHAR >>> HOW???

      CASE CONVERT_TO_INT:
          convert onetype VOID TO INT >>> HOW???

   LOT OF CASES...
   }
}

Yes, I know type casting, but type casting is a 'temporary' change.

So, is there any way to accomplish it in C?

EDIT :

Stop stop stop! Please, see, what are you doing is type casting, I KNOW THIS, you are creating another variable of the desirable type like int i = (int) onetype, I don't want this, I want something else like onetype = (int) onetype, without recreate them, without allocate another variable.

Thanks a lot guys!

Answer 1

int lolcakes = *(void*)onetype;

This is assuming that you know for sure that onetype points to an int. Using this type of casting is incredibly unsafe.

Answer 2

It sounds like your scenario is as follows

• void* onetype holds a pointer to a strongly typed variable
• USER_INPUT_TYPE tells you the type of that variable

If that's the case then try the following

switch (USER_INPUT_TYPE) {
case CONVERT_TO_CHAR:
  char c = *((char*)onetype);
  ...
  break;
case CONVERT_TO_INT:
  int i = *((int*)onetype);
  ...
  break;


}

Answer 3

What you want is run-time type information - to have a variable in which the type is only determinable at run time. C does NOT have this functionality in the language - once the program is compiled, types are erased, and only memory blobs exist. Dynamic languages maintain type information and implement this natively.

You can devise your own home-grown type tagging system:

typedef union {
int i;
char c;
float f;
} evil;

typedef struct {
  evil value;
  int type;
} tagged_t;

enum {
  TYPE_INT, TYPE_CHAR, TYPE_FLOAT
};

tagged_t bar;
bar.value.c = 'a';
bar.type = TYPE_CHAR;

Now every time you wish to use your tagged_t type, you must implement a condition for each possible type of variable you are storing, or be able to determine whether a type is allowed in that area of code or not.